From 22298ad9c3219f57d698a9d943f2bc503ac3f752 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Tue, 23 May 2023 16:16:40 -0400 Subject: [PATCH 01/14] Add XML and zap gen for dish alarm --- .github/workflows/tests.yaml | 1 + scripts/rules.matterlint | 1 + src/app/zap-templates/zcl/data-model/all.xml | 1 + .../zcl/data-model/chip/dishwasher-alarm.xml | 58 ++ .../zcl/zcl-with-test-extensions.json | 1 + src/app/zap-templates/zcl/zcl.json | 1 + src/app/zap_cluster_list.json | 1 + .../data_model/controller-clusters.matter | 37 + .../data_model/controller-clusters.zap | 209 ++++- .../CHIPAttributeTLVValueDecoder.cpp | 181 ++++ .../zap-generated/CHIPClustersWrite-JNI.cpp | 52 ++ .../CHIPEventTLVValueDecoder.cpp | 62 ++ .../java/zap-generated/CHIPReadCallbacks.cpp | 282 +++++++ .../chip/devicecontroller/ChipClusters.java | 218 +++++ .../devicecontroller/ChipEventStructs.java | 34 + .../chip/devicecontroller/ChipIdLookup.java | 39 + .../devicecontroller/ClusterInfoMapping.java | 126 +++ .../python/chip/clusters/CHIPClusters.py | 73 ++ .../python/chip/clusters/Objects.py | 229 +++++ .../MTRAttributeTLVValueDecoder.mm | 175 ++++ .../CHIP/zap-generated/MTRBaseClusters.h | 146 ++++ .../CHIP/zap-generated/MTRBaseClusters.mm | 486 +++++++++++ .../zap-generated/MTRBaseClusters_Internal.h | 5 + .../CHIP/zap-generated/MTRCallbackBridge.h | 232 ++++++ .../CHIP/zap-generated/MTRCallbackBridge.mm | 221 +++++ .../CHIP/zap-generated/MTRClusterConstants.h | 23 + .../CHIP/zap-generated/MTRClusters.h | 44 + .../CHIP/zap-generated/MTRClusters.mm | 180 ++++ .../CHIP/zap-generated/MTRClusters_Internal.h | 5 + .../zap-generated/MTRCommandPayloadsObjc.h | 32 + .../zap-generated/MTRCommandPayloadsObjc.mm | 34 + .../zap-generated/MTREventTLVValueDecoder.mm | 47 ++ .../CHIP/zap-generated/MTRStructsObjc.h | 8 + .../CHIP/zap-generated/MTRStructsObjc.mm | 37 + .../zap-generated/attributes/Accessors.cpp | 161 ++++ .../zap-generated/attributes/Accessors.h | 31 + .../app-common/zap-generated/callback.h | 92 +++ .../app-common/zap-generated/cluster-enums.h | 14 + .../zap-generated/cluster-objects.cpp | 146 ++++ .../zap-generated/cluster-objects.h | 193 +++++ .../app-common/zap-generated/ids/Attributes.h | 42 + .../app-common/zap-generated/ids/Clusters.h | 3 + .../app-common/zap-generated/ids/Commands.h | 10 + .../app-common/zap-generated/ids/Events.h | 10 + .../app-common/zap-generated/print-cluster.h | 7 + .../zap-generated/cluster/Commands.h | 120 +++ .../cluster/logging/DataModelLogger.cpp | 102 +++ .../cluster/logging/DataModelLogger.h | 2 + .../zap-generated/cluster/Commands.h | 782 ++++++++++++++++++ .../zap-generated/CHIPClientCallbacks.h | 8 + .../zap-generated/CHIPClusters.h | 9 + .../zap-generated/endpoint_config.h | 17 +- .../zap-generated/gen_config.h | 5 + 53 files changed, 5032 insertions(+), 3 deletions(-) create mode 100644 src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index dcf34d4ad8b125..d6c4beb9a9b026 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -139,6 +139,7 @@ jobs: src/app/zap-templates/zcl/data-model/chip/content-launch-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/descriptor-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/diagnostic-logs-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml \ src/app/zap-templates/zcl/data-model/chip/door-lock-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/ethernet-network-diagnostics-cluster.xml \ src/app/zap-templates/zcl/data-model/chip/fan-control-cluster.xml \ diff --git a/scripts/rules.matterlint b/scripts/rules.matterlint index 98b9f085b573ba..fee2ca547ee216 100644 --- a/scripts/rules.matterlint +++ b/scripts/rules.matterlint @@ -22,6 +22,7 @@ load "../src/app/zap-templates/zcl/data-model/chip/color-control-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/content-launch-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/descriptor-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/diagnostic-logs-cluster.xml"; +load "../src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml"; load "../src/app/zap-templates/zcl/data-model/chip/door-lock-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/ethernet-network-diagnostics-cluster.xml"; load "../src/app/zap-templates/zcl/data-model/chip/fan-control-cluster.xml"; diff --git a/src/app/zap-templates/zcl/data-model/all.xml b/src/app/zap-templates/zcl/data-model/all.xml index 56d251c3610b23..2fbd9b066ddb95 100644 --- a/src/app/zap-templates/zcl/data-model/all.xml +++ b/src/app/zap-templates/zcl/data-model/all.xml @@ -20,6 +20,7 @@ + diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml new file mode 100644 index 00000000000000..a69c9deed73ccb --- /dev/null +++ b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml @@ -0,0 +1,58 @@ + + + + + + + + + + + + + + + + + Dishwasher Alarm + Appliances + Attributes and commands for configuring the Dishwasher alarm. + 0x005D + DISHWASHER_ALARM + + true + true + + Mask + Latch + State + + + Reset alarm + + + + + + Notify + + + + + + + diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json index bf09285691e2e9..a5bef9901b754e 100644 --- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json +++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json @@ -34,6 +34,7 @@ "content-launch-cluster.xml", "descriptor-cluster.xml", "diagnostic-logs-cluster.xml", + "dishwasher-alarm.xml", "door-lock-cluster.xml", "electrical-measurement-cluster.xml", "ethernet-network-diagnostics-cluster.xml", diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json index 3d56644adf6da2..28f08feb8e2493 100644 --- a/src/app/zap-templates/zcl/zcl.json +++ b/src/app/zap-templates/zcl/zcl.json @@ -33,6 +33,7 @@ "content-launch-cluster.xml", "descriptor-cluster.xml", "diagnostic-logs-cluster.xml", + "dishwasher-alarm.xml", "door-lock-cluster.xml", "electrical-measurement-cluster.xml", "ethernet-network-diagnostics-cluster.xml", diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json index eb9c236e7c369e..b12e214679e3ee 100644 --- a/src/app/zap_cluster_list.json +++ b/src/app/zap_cluster_list.json @@ -26,6 +26,7 @@ "DESCRIPTOR_CLUSTER": [], "DEVICE_TEMP_CLUSTER": [], "DIAGNOSTIC_LOGS_CLUSTER": [], + "DISHWASHER_ALARM": [], "DOOR_LOCK_CLUSTER": [], "ELECTRICAL_MEASUREMENT_CLUSTER": [], "ELECTROSTATIC_FILTER_MONITORING_CLUSTER": [], diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index 0eb643f80cf4b3..55f9434c9bb148 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -2974,6 +2974,43 @@ client cluster SmokeCoAlarm = 92 { command SelfTestRequest(): DefaultSuccess = 0; } +/** Attributes and commands for configuring the Dishwasher alarm. */ +client cluster DishwasherAlarm = 93 { + bitmap AlarmMap : BITMAP32 { + kInflowError = 0x1; + kDrainError = 0x2; + kDoorError = 0x4; + kTempTooLow = 0x8; + kTempTooHigh = 0x10; + kWaterLevelError = 0x11; + } + + info event Notify = 0 { + AlarmMap active = 0; + AlarmMap inactive = 1; + AlarmMap state = 2; + AlarmMap mask = 3; + } + + attribute AlarmMap mask = 0; + readonly attribute AlarmMap latch = 1; + readonly attribute AlarmMap state = 2; + readonly attribute command_id generatedCommandList[] = 65528; + readonly attribute command_id acceptedCommandList[] = 65529; + readonly attribute event_id eventList[] = 65530; + readonly attribute attrib_id attributeList[] = 65531; + readonly attribute bitmap32 featureMap = 65532; + readonly attribute int16u clusterRevision = 65533; + + request struct ResetRequest { + AlarmMap alarms = 0; + optional AlarmMap mask = 1; + } + + /** Reset alarm */ + command Reset(ResetRequest): DefaultSuccess = 0; +} + /** Attributes and commands for monitoring HEPA filters in a device */ client cluster HepaFilterMonitoring = 113 { enum ChangeIndicationEnum : ENUM8 { diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 4726c9905368ad..7ddb695558c77a 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -10996,6 +10996,212 @@ } ] }, + { + "name": "Dishwasher Alarm", + "code": 93, + "mfgCode": null, + "define": "DISHWASHER_ALARM", + "side": "client", + "enabled": 1, + "commands": [ + { + "name": "Reset", + "code": 0, + "mfgCode": null, + "source": "client", + "incoming": 0, + "outgoing": 1 + } + ], + "attributes": [ + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "client", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, + { + "name": "Dishwasher Alarm", + "code": 93, + "mfgCode": null, + "define": "DISHWASHER_ALARM", + "side": "server", + "enabled": 0, + "attributes": [ + { + "name": "Mask", + "code": 0, + "mfgCode": null, + "side": "server", + "type": "AlarmMap", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "Latch", + "code": 1, + "mfgCode": null, + "side": "server", + "type": "AlarmMap", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "State", + "code": 2, + "mfgCode": null, + "side": "server", + "type": "AlarmMap", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "GeneratedCommandList", + "code": 65528, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AcceptedCommandList", + "code": 65529, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "EventList", + "code": 65530, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "type": "array", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "type": "bitmap32", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "type": "int16u", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + } + ] + }, { "name": "HEPA Filter Monitoring", "code": 113, @@ -24845,5 +25051,6 @@ "endpointVersion": 1, "deviceIdentifier": 22 } - ] + ], + "log": [] } \ No newline at end of file diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp index 83f0c0b049b319..0c41ccdb96a6b6 100644 --- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp @@ -13081,6 +13081,187 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR } break; } + case app::Clusters::DishwasherAlarm::Id: { + using namespace app::Clusters::DishwasherAlarm; + switch (aPath.mAttributeId) + { + case Attributes::Mask::Id: { + using TypeInfo = Attributes::Mask::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.Raw(), value); + return value; + } + case Attributes::Latch::Id: { + using TypeInfo = Attributes::Latch::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.Raw(), value); + return value; + } + case Attributes::State::Id: { + using TypeInfo = Attributes::State::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.Raw(), 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 3b922d4f5a09d4..323dbb429b4482 100644 --- a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp @@ -2446,6 +2446,58 @@ JNI_METHOD(void, SmokeCoAlarmCluster, writeSensitivityLevelAttribute) onFailure.release(); } +JNI_METHOD(void, DishwasherAlarmCluster, writeMaskAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::DishwasherAlarm::Attributes::Mask::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + cppValue.SetRaw(static_cast::IntegerType>( + chip::JniReferences::GetInstance().LongToPrimitive(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; + DishwasherAlarmCluster * 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 698b243a3100d1..1979227727670c 100644 --- a/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPEventTLVValueDecoder.cpp @@ -2803,6 +2803,68 @@ jobject DecodeEventValue(const app::ConcreteEventPath & aPath, TLV::TLVReader & } break; } + case app::Clusters::DishwasherAlarm::Id: { + using namespace app::Clusters::DishwasherAlarm; + switch (aPath.mEventId) + { + case Events::Notify::Id: { + Events::Notify::DecodableType cppValue; + *aError = app::DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) + { + return nullptr; + } + jobject value_active; + std::string value_activeClassName = "java/lang/Long"; + std::string value_activeCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + value_activeClassName.c_str(), value_activeCtorSignature.c_str(), cppValue.active.Raw(), value_active); + + jobject value_inactive; + std::string value_inactiveClassName = "java/lang/Long"; + std::string value_inactiveCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + value_inactiveClassName.c_str(), value_inactiveCtorSignature.c_str(), cppValue.inactive.Raw(), value_inactive); + + jobject value_state; + std::string value_stateClassName = "java/lang/Long"; + std::string value_stateCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + value_stateClassName.c_str(), value_stateCtorSignature.c_str(), cppValue.state.Raw(), value_state); + + jobject value_mask; + std::string value_maskClassName = "java/lang/Long"; + std::string value_maskCtorSignature = "(J)V"; + chip::JniReferences::GetInstance().CreateBoxedObject( + value_maskClassName.c_str(), value_maskCtorSignature.c_str(), cppValue.mask.Raw(), value_mask); + + jclass notifyStructClass; + err = chip::JniReferences::GetInstance().GetClassRef( + env, "chip/devicecontroller/ChipEventStructs$DishwasherAlarmClusterNotifyEvent", notifyStructClass); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Zcl, "Could not find class ChipEventStructs$DishwasherAlarmClusterNotifyEvent"); + return nullptr; + } + jmethodID notifyStructCtor = env->GetMethodID(notifyStructClass, "", + "(Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;Ljava/lang/Long;)V"); + if (notifyStructCtor == nullptr) + { + ChipLogError(Zcl, "Could not find ChipEventStructs$DishwasherAlarmClusterNotifyEvent constructor"); + return nullptr; + } + + jobject value = + env->NewObject(notifyStructClass, notifyStructCtor, value_active, value_inactive, value_state, value_mask); + + 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 67b729f61bba45..2752240f7b83f9 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -21460,6 +21460,288 @@ void CHIPSmokeCoAlarmAttributeListAttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPDishwasherAlarmGeneratedCommandListAttributeCallback::CHIPDishwasherAlarmGeneratedCommandListAttributeCallback( + 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"); + } +} + +CHIPDishwasherAlarmGeneratedCommandListAttributeCallback::~CHIPDishwasherAlarmGeneratedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPDishwasherAlarmGeneratedCommandListAttributeCallback::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); +} + +CHIPDishwasherAlarmAcceptedCommandListAttributeCallback::CHIPDishwasherAlarmAcceptedCommandListAttributeCallback( + 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"); + } +} + +CHIPDishwasherAlarmAcceptedCommandListAttributeCallback::~CHIPDishwasherAlarmAcceptedCommandListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPDishwasherAlarmAcceptedCommandListAttributeCallback::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); +} + +CHIPDishwasherAlarmEventListAttributeCallback::CHIPDishwasherAlarmEventListAttributeCallback(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"); + } +} + +CHIPDishwasherAlarmEventListAttributeCallback::~CHIPDishwasherAlarmEventListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPDishwasherAlarmEventListAttributeCallback::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); +} + +CHIPDishwasherAlarmAttributeListAttributeCallback::CHIPDishwasherAlarmAttributeListAttributeCallback(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"); + } +} + +CHIPDishwasherAlarmAttributeListAttributeCallback::~CHIPDishwasherAlarmAttributeListAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPDishwasherAlarmAttributeListAttributeCallback::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 1337fd000a1edc..19c6696802d9a9 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -14853,6 +14853,224 @@ private native void subscribeClusterRevisionAttribute( long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } + public static class DishwasherAlarmCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 93L; + + public DishwasherAlarmCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void reset(DefaultClusterCallback callback, Long alarms, Optional mask) { + reset(chipClusterPtr, callback, alarms, mask, null); + } + + public void reset( + DefaultClusterCallback callback, + Long alarms, + Optional mask, + int timedInvokeTimeoutMs) { + reset(chipClusterPtr, callback, alarms, mask, timedInvokeTimeoutMs); + } + + private native void reset( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long alarms, + Optional mask, + @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 readMaskAttribute(LongAttributeCallback callback) { + readMaskAttribute(chipClusterPtr, callback); + } + + public void writeMaskAttribute(DefaultClusterCallback callback, Long value) { + writeMaskAttribute(chipClusterPtr, callback, value, null); + } + + public void writeMaskAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeMaskAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + + public void subscribeMaskAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLatchAttribute(LongAttributeCallback callback) { + readLatchAttribute(chipClusterPtr, callback); + } + + public void subscribeLatchAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeLatchAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readStateAttribute(LongAttributeCallback callback) { + readStateAttribute(chipClusterPtr, callback); + } + + public void subscribeStateAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeStateAttribute(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 readMaskAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeMaskAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaskAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLatchAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeLatchAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStateAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeStateAttribute( + long chipClusterPtr, LongAttributeCallback 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 6a0bfaa39f51f0..6b89fd12df3447 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipEventStructs.java @@ -1140,6 +1140,40 @@ public String toString() { } } + public static class DishwasherAlarmClusterNotifyEvent { + public Long active; + public Long inactive; + public Long state; + public Long mask; + + public DishwasherAlarmClusterNotifyEvent(Long active, Long inactive, Long state, Long mask) { + this.active = active; + this.inactive = inactive; + this.state = state; + this.mask = mask; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DishwasherAlarmClusterNotifyEvent {\n"); + output.append("\tactive: "); + output.append(active); + output.append("\n"); + output.append("\tinactive: "); + output.append(inactive); + output.append("\n"); + output.append("\tstate: "); + output.append(state); + output.append("\n"); + output.append("\tmask: "); + output.append(mask); + output.append("\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 c550130d9c7f19..32d1a3627eaa6d 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java @@ -162,6 +162,9 @@ public static String clusterIdToName(long clusterId) { if (clusterId == 92L) { return "SmokeCoAlarm"; } + if (clusterId == 93L) { + return "DishwasherAlarm"; + } if (clusterId == 113L) { return "HepaFilterMonitoring"; } @@ -2186,6 +2189,36 @@ public static String attributeIdToName(long clusterId, long attributeId) { } return ""; } + if (clusterId == 93L) { + if (attributeId == 0L) { + return "Mask"; + } + if (attributeId == 1L) { + return "Latch"; + } + if (attributeId == 2L) { + return "State"; + } + 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"; @@ -5008,6 +5041,12 @@ public static String eventIdToName(long clusterId, long eventId) { } return ""; } + if (clusterId == 93L) { + if (eventId == 0L) { + return "Notify"; + } + 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 474738799cb898..3d861a2de52214 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -7776,6 +7776,102 @@ public void onError(Exception ex) { } } + public static class DelegatedDishwasherAlarmClusterGeneratedCommandListAttributeCallback + implements ChipClusters.DishwasherAlarmCluster.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 DelegatedDishwasherAlarmClusterAcceptedCommandListAttributeCallback + implements ChipClusters.DishwasherAlarmCluster.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 DelegatedDishwasherAlarmClusterEventListAttributeCallback + implements ChipClusters.DishwasherAlarmCluster.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 DelegatedDishwasherAlarmClusterAttributeListAttributeCallback + implements ChipClusters.DishwasherAlarmCluster.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 { @@ -15784,6 +15880,11 @@ public Map initializeClusterMap() { (ptr, endpointId) -> new ChipClusters.SmokeCoAlarmCluster(ptr, endpointId), new HashMap<>()); clusterMap.put("smokeCoAlarm", smokeCoAlarmClusterInfo); + ClusterInfo dishwasherAlarmClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DishwasherAlarmCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("dishwasherAlarm", dishwasherAlarmClusterInfo); ClusterInfo hepaFilterMonitoringClusterInfo = new ClusterInfo( (ptr, endpointId) -> new ChipClusters.HepaFilterMonitoringCluster(ptr, endpointId), @@ -16068,6 +16169,7 @@ public void combineCommand( destination.get("refrigeratorAlarm").combineCommands(source.get("refrigeratorAlarm")); destination.get("airQuality").combineCommands(source.get("airQuality")); destination.get("smokeCoAlarm").combineCommands(source.get("smokeCoAlarm")); + destination.get("dishwasherAlarm").combineCommands(source.get("dishwasherAlarm")); destination.get("hepaFilterMonitoring").combineCommands(source.get("hepaFilterMonitoring")); destination .get("activatedCarbonFilterMonitoring") @@ -18269,6 +18371,30 @@ public Map> getCommandMap() { smokeCoAlarmClusterInteractionInfoMap.put( "selfTestRequest", smokeCoAlarmselfTestRequestInteractionInfo); commandMap.put("smokeCoAlarm", smokeCoAlarmClusterInteractionInfoMap); + Map dishwasherAlarmClusterInteractionInfoMap = new LinkedHashMap<>(); + Map dishwasherAlarmresetCommandParams = + new LinkedHashMap(); + CommandParameterInfo dishwasherAlarmresetalarmsCommandParameterInfo = + new CommandParameterInfo("alarms", Long.class, Long.class); + dishwasherAlarmresetCommandParams.put("alarms", dishwasherAlarmresetalarmsCommandParameterInfo); + + CommandParameterInfo dishwasherAlarmresetmaskCommandParameterInfo = + new CommandParameterInfo("mask", Optional.class, Long.class); + dishwasherAlarmresetCommandParams.put("mask", dishwasherAlarmresetmaskCommandParameterInfo); + + InteractionInfo dishwasherAlarmresetInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .reset( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("alarms"), + (Optional) commandArguments.get("mask")); + }, + () -> new DelegatedDefaultClusterCallback(), + dishwasherAlarmresetCommandParams); + dishwasherAlarmClusterInteractionInfoMap.put("reset", dishwasherAlarmresetInteractionInfo); + commandMap.put("dishwasherAlarm", dishwasherAlarmClusterInteractionInfoMap); 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 953042902a6514..796431d2799e90 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -4678,6 +4678,77 @@ class ChipClusters: }, }, } + _DISHWASHER_ALARM_CLUSTER_INFO = { + "clusterName": "DishwasherAlarm", + "clusterId": 0x0000005D, + "commands": { + 0x00000000: { + "commandId": 0x00000000, + "commandName": "Reset", + "args": { + "alarms": "int", + "mask": "int", + }, + }, + }, + "attributes": { + 0x00000000: { + "attributeName": "Mask", + "attributeId": 0x00000000, + "type": "int", + "reportable": True, + "writable": True, + }, + 0x00000001: { + "attributeName": "Latch", + "attributeId": 0x00000001, + "type": "int", + "reportable": True, + }, + 0x00000002: { + "attributeName": "State", + "attributeId": 0x00000002, + "type": "int", + "reportable": 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, @@ -10981,6 +11052,7 @@ class ChipClusters: 0x00000057: _REFRIGERATOR_ALARM_CLUSTER_INFO, 0x0000005B: _AIR_QUALITY_CLUSTER_INFO, 0x0000005C: _SMOKE_CO_ALARM_CLUSTER_INFO, + 0x0000005D: _DISHWASHER_ALARM_CLUSTER_INFO, 0x00000071: _HEPA_FILTER_MONITORING_CLUSTER_INFO, 0x00000072: _ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_INFO, 0x00000073: _CERAMIC_FILTER_MONITORING_CLUSTER_INFO, @@ -11072,6 +11144,7 @@ class ChipClusters: "RefrigeratorAlarm": _REFRIGERATOR_ALARM_CLUSTER_INFO, "AirQuality": _AIR_QUALITY_CLUSTER_INFO, "SmokeCoAlarm": _SMOKE_CO_ALARM_CLUSTER_INFO, + "DishwasherAlarm": _DISHWASHER_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/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 1b26cf02151a32..2aa966d38b467d 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -16356,6 +16356,235 @@ def descriptor(cls) -> ClusterObjectDescriptor: ]) +@dataclass +class DishwasherAlarm(Cluster): + id: typing.ClassVar[int] = 0x005D + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="mask", Tag=0x00000000, Type=uint), + ClusterObjectFieldDescriptor(Label="latch", Tag=0x00000001, Type=uint), + ClusterObjectFieldDescriptor(Label="state", Tag=0x00000002, Type=uint), + ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="eventList", Tag=0x0000FFFA, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="attributeList", Tag=0x0000FFFB, Type=typing.List[uint]), + ClusterObjectFieldDescriptor(Label="featureMap", Tag=0x0000FFFC, Type=uint), + ClusterObjectFieldDescriptor(Label="clusterRevision", Tag=0x0000FFFD, Type=uint), + ]) + + mask: 'uint' = None + latch: 'uint' = None + state: 'uint' = None + generatedCommandList: 'typing.List[uint]' = None + acceptedCommandList: 'typing.List[uint]' = None + eventList: 'typing.List[uint]' = None + attributeList: 'typing.List[uint]' = None + featureMap: 'uint' = None + clusterRevision: 'uint' = None + + class Bitmaps: + class AlarmMap(IntFlag): + kInflowError = 0x1 + kDrainError = 0x2 + kDoorError = 0x4 + kTempTooLow = 0x8 + kTempTooHigh = 0x10 + kWaterLevelError = 0x11 + + class Commands: + @dataclass + class Reset(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x005D + command_id: typing.ClassVar[int] = 0x00000000 + is_client: typing.ClassVar[bool] = True + response_type: typing.ClassVar[str] = None + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="alarms", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="mask", Tag=1, Type=typing.Optional[uint]), + ]) + + alarms: 'uint' = 0 + mask: 'typing.Optional[uint]' = None + + class Attributes: + @dataclass + class Mask(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class Latch(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000001 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class State(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000002 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class GeneratedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF8 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AcceptedCommandList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFF9 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class EventList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFA + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class AttributeList(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFB + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=typing.List[uint]) + + value: 'typing.List[uint]' = field(default_factory=lambda: []) + + @dataclass + class FeatureMap(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFC + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + @dataclass + class ClusterRevision(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x0000FFFD + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + + class Events: + @dataclass + class Notify(ClusterEvent): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def event_id(cls) -> int: + return 0x00000000 + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor(Label="active", Tag=0, Type=uint), + ClusterObjectFieldDescriptor(Label="inactive", Tag=1, Type=uint), + ClusterObjectFieldDescriptor(Label="state", Tag=2, Type=uint), + ClusterObjectFieldDescriptor(Label="mask", Tag=3, Type=uint), + ]) + + active: 'uint' = 0 + inactive: 'uint' = 0 + state: 'uint' = 0 + mask: 'uint' = 0 + + @dataclass class HepaFilterMonitoring(Cluster): id: typing.ClassVar[int] = 0x0071 diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm index a5027126bde65b..bd58e12660425c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm @@ -9839,6 +9839,178 @@ static id _Nullable DecodeAttributeValueForSmokeCOAlarmCluster( *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; return nil; } +static id _Nullable DecodeAttributeValueForDishwasherAlarmCluster( + AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::DishwasherAlarm; + switch (aAttributeId) { + case Attributes::Mask::Id: { + using TypeInfo = Attributes::Mask::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedInt:cppValue.Raw()]; + return value; + } + case Attributes::Latch::Id: { + using TypeInfo = Attributes::Latch::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedInt:cppValue.Raw()]; + return value; + } + case Attributes::State::Id: { + using TypeInfo = Attributes::State::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedInt:cppValue.Raw()]; + return value; + } + case Attributes::GeneratedCommandList::Id: { + using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::AcceptedCommandList::Id: { + using TypeInfo = Attributes::AcceptedCommandList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::EventList::Id: { + using TypeInfo = Attributes::EventList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::AttributeList::Id: { + using TypeInfo = Attributes::AttributeList::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSArray * _Nonnull value; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = cppValue.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + *aError = err; + return nil; + } + value = array_0; + } + return value; + } + case Attributes::FeatureMap::Id: { + using TypeInfo = Attributes::FeatureMap::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedInt:cppValue]; + return value; + } + case Attributes::ClusterRevision::Id: { + using TypeInfo = Attributes::ClusterRevision::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedShort:cppValue]; + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB; + return nil; +} static id _Nullable DecodeAttributeValueForHEPAFilterMonitoringCluster( AttributeId aAttributeId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { @@ -22667,6 +22839,9 @@ id _Nullable MTRDecodeAttributeValue(const ConcreteAttributePath & aPath, TLV::T case Clusters::SmokeCoAlarm::Id: { return DecodeAttributeValueForSmokeCOAlarmCluster(aPath.mAttributeId, aReader, aError); } + case Clusters::DishwasherAlarm::Id: { + return DecodeAttributeValueForDishwasherAlarmCluster(aPath.mAttributeId, aReader, aError); + } case Clusters::HepaFilterMonitoring::Id: { return DecodeAttributeValueForHEPAFilterMonitoringCluster(aPath.mAttributeId, aReader, aError); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index 057bcd7b7efca4..f349f0df1abb66 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -8526,6 +8526,143 @@ MTR_NEWLY_AVAILABLE @end +/** + * Cluster Dishwasher Alarm + * + * Attributes and commands for configuring the Dishwasher alarm. + */ +MTR_NEWLY_AVAILABLE +@interface MTRBaseClusterDishwasherAlarm : MTRCluster + +- (instancetype _Nullable)initWithDevice:(MTRBaseDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER MTR_NEWLY_AVAILABLE; + +/** + * Command Reset + * + * Reset alarm + */ +- (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params + completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; + +- (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; +- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value + params:(MTRWriteParams * _Nullable)params + completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeMaskWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + +- (void)readAttributeLatchWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeLatchWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeLatchWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + +- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler MTR_NEWLY_AVAILABLE; ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE; + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))reportHandler MTR_NEWLY_AVAILABLE; ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSArray * _Nullable value, + NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE; + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + /** * Cluster HEPA Filter Monitoring * @@ -23408,6 +23545,15 @@ typedef NS_OPTIONS(uint32_t, MTRSmokeCOAlarmFeature) { MTRSmokeCOAlarmFeatureCOAlarm MTR_NEWLY_AVAILABLE = 0x2, } MTR_NEWLY_AVAILABLE; +typedef NS_OPTIONS(uint32_t, MTRDishwasherAlarmAlarmMap) { + MTRDishwasherAlarmAlarmMapInflowError MTR_NEWLY_AVAILABLE = 0x1, + MTRDishwasherAlarmAlarmMapDrainError MTR_NEWLY_AVAILABLE = 0x2, + MTRDishwasherAlarmAlarmMapDoorError MTR_NEWLY_AVAILABLE = 0x4, + MTRDishwasherAlarmAlarmMapTempTooLow MTR_NEWLY_AVAILABLE = 0x8, + MTRDishwasherAlarmAlarmMapTempTooHigh MTR_NEWLY_AVAILABLE = 0x10, + MTRDishwasherAlarmAlarmMapWaterLevelError MTR_NEWLY_AVAILABLE = 0x11, +} MTR_NEWLY_AVAILABLE; + typedef NS_ENUM(uint8_t, MTRHEPAFilterMonitoringChangeIndication) { MTRHEPAFilterMonitoringChangeIndicationOK MTR_NEWLY_AVAILABLE = 0x00, MTRHEPAFilterMonitoringChangeIndicationWarning MTR_NEWLY_AVAILABLE = 0x01, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm index 0d495ffe954171..c46970bb547127 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm @@ -50093,6 +50093,492 @@ + (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheC @end +@implementation MTRBaseClusterDishwasherAlarm + +- (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue +{ + if (self = [super initWithQueue:queue]) { + if (device == nil) { + return nil; + } + + _device = device; + _endpoint = [endpointID unsignedShortValue]; + } + return self; +} + +- (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + auto * bridge = new MTRCommandSuccessCallbackBridge( + self.callbackQueue, + ^(id _Nullable value, NSError * _Nullable error) { + completion(error); + }, + ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb, + MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + auto * typedBridge = static_cast(bridge); + Optional timedInvokeTimeoutMs; + Optional invokeTimeout; + ListFreer listFreer; + DishwasherAlarm::Commands::Reset::Type request; + if (params != nil) { + if (params.timedInvokeTimeoutMs != nil) { + params.timedInvokeTimeoutMs = MTRClampedNumber(params.timedInvokeTimeoutMs, @(1), @(UINT16_MAX)); + timedInvokeTimeoutMs.SetValue(params.timedInvokeTimeoutMs.unsignedShortValue); + } + if (params.serverSideProcessingTimeout != nil) { + // Clamp to a number of seconds that will not overflow 32-bit + // int when converted to ms. + auto * serverSideProcessingTimeout = MTRClampedNumber(params.serverSideProcessingTimeout, @(0), @(UINT16_MAX)); + invokeTimeout.SetValue(Seconds16(serverSideProcessingTimeout.unsignedShortValue)); + } + } + request.alarms = static_cast>(params.alarms.unsignedIntValue); + if (params.mask != nil) { + auto & definedValue_0 = request.mask.Emplace(); + definedValue_0 = static_cast>(params.mask.unsignedIntValue); + } + + return MTRStartInvokeInteraction(typedBridge, request, exchangeManager, session, successCb, failureCb, self->_endpoint, + timedInvokeTimeoutMs, invokeTimeout); + }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value completion:(MTRStatusCompletion)completion +{ + [self writeAttributeMaskWithValue:(NSNumber * _Nonnull) value params:nil completion:completion]; +} +- (void)writeAttributeMaskWithValue:(NSNumber * _Nonnull)value + params:(MTRWriteParams * _Nullable)params + completion:(MTRStatusCompletion)completion +{ + // Make a copy of params before we go async. + params = [params copy]; + value = [value copy]; + + auto * bridge = new MTRDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(id _Nullable ignored, NSError * _Nullable error) { + completion(error); + }, + ^(ExchangeManager & exchangeManager, const SessionHandle & session, DefaultSuccessCallbackType successCb, + MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + chip::Optional timedWriteTimeout; + if (params != nil) { + if (params.timedWriteTimeout != nil) { + timedWriteTimeout.SetValue(params.timedWriteTimeout.unsignedShortValue); + } + } + + ListFreer listFreer; + using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo; + TypeInfo::Type cppValue; + cppValue = static_cast>(value.unsignedIntValue); + + chip::Controller::ClusterBase cppCluster(exchangeManager, session, self->_endpoint); + return cppCluster.WriteAttribute(cppValue, bridge, successCb, failureCb, timedWriteTimeout); + }); + std::move(*bridge).DispatchAction(self.device); +} + +- (void)subscribeAttributeMaskWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo; + MTRSubscribeAttribute(params, + subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeMaskWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmMaskAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction( + clusterStateCacheContainer.baseDevice, ^(DishwasherAlarmMaskAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::Mask::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeLatchWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::Latch::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeLatchWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::Latch::TypeInfo; + MTRSubscribeAttribute(params, + subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeLatchWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmLatchAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction( + clusterStateCacheContainer.baseDevice, ^(DishwasherAlarmLatchAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::Latch::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeStateWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::State::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeStateWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::State::TypeInfo; + MTRSubscribeAttribute(params, + subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmStateAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction( + clusterStateCacheContainer.baseDevice, ^(DishwasherAlarmStateAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::State::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::GeneratedCommandList::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::GeneratedCommandList::TypeInfo; + MTRSubscribeAttribute(params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, + TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeGeneratedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice, + ^(DishwasherAlarmGeneratedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::GeneratedCommandList::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeAcceptedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::AcceptedCommandList::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeAcceptedCommandListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::AcceptedCommandList::TypeInfo; + MTRSubscribeAttribute(params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, + TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeAcceptedCommandListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion: + (void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice, + ^(DishwasherAlarmAcceptedCommandListListAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::AcceptedCommandList::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeEventListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::EventList::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeEventListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::EventList::TypeInfo; + MTRSubscribeAttribute( + params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeEventListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmEventListListAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice, + ^(DishwasherAlarmEventListListAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::EventList::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeAttributeListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::AttributeList::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeAttributeListWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::AttributeList::TypeInfo; + MTRSubscribeAttribute( + params, subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeAttributeListWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmAttributeListListAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction(clusterStateCacheContainer.baseDevice, + ^(DishwasherAlarmAttributeListListAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::AttributeList::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeFeatureMapWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::FeatureMap::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeFeatureMapWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::FeatureMap::TypeInfo; + MTRSubscribeAttribute(params, + subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeFeatureMapWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRInt32uAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction( + clusterStateCacheContainer.baseDevice, ^(Int32uAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::FeatureMap::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +- (void)readAttributeClusterRevisionWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::ClusterRevision::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeClusterRevisionWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::ClusterRevision::TypeInfo; + MTRSubscribeAttribute(params, + subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeClusterRevisionWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion: + (void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRInt16uAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction( + clusterStateCacheContainer.baseDevice, ^(Int16uAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::ClusterRevision::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + +@end + @implementation MTRBaseClusterHEPAFilterMonitoring - (instancetype)initWithDevice:(MTRBaseDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h index 5aadb7f0a173af..bbf9d7242dc2ff 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters_Internal.h @@ -220,6 +220,11 @@ @property (nonatomic, assign, readonly) chip::EndpointId endpoint; @end +@interface MTRBaseClusterDishwasherAlarm () +@property (nonatomic, strong, readonly) MTRBaseDevice * device; +@property (nonatomic, assign, readonly) chip::EndpointId endpoint; +@end + @interface MTRBaseClusterHEPAFilterMonitoring () @property (nonatomic, strong, readonly) MTRBaseDevice * device; @property (nonatomic, assign, readonly) chip::EndpointId endpoint; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h index 19ce55f7c414ea..b14924eaba699e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h @@ -1134,6 +1134,17 @@ typedef void (*SmokeCOAlarmEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); typedef void (*SmokeCOAlarmAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmMaskAttributeCallback)(void *, chip::BitMask); +typedef void (*DishwasherAlarmLatchAttributeCallback)(void *, chip::BitMask); +typedef void (*DishwasherAlarmStateAttributeCallback)(void *, chip::BitMask); +typedef void (*DishwasherAlarmGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); typedef void (*HEPAFilterMonitoringGeneratedCommandListListAttributeCallback)( void * context, const chip::app::DataModel::DecodableList & data); typedef void (*HEPAFilterMonitoringAcceptedCommandListListAttributeCallback)( @@ -9238,6 +9249,227 @@ class MTRSmokeCOAlarmAttributeListListAttributeCallbackSubscriptionBridge MTRSubscriptionEstablishedHandler mEstablishedHandler; }; +class MTRDishwasherAlarmMaskAttributeCallbackBridge : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmMaskAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmMaskAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, chip::BitMask value); +}; + +class MTRDishwasherAlarmMaskAttributeCallbackSubscriptionBridge : public MTRDishwasherAlarmMaskAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmMaskAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmMaskAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmMaskAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmMaskAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + +class MTRDishwasherAlarmLatchAttributeCallbackBridge : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmLatchAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmLatchAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, chip::BitMask value); +}; + +class MTRDishwasherAlarmLatchAttributeCallbackSubscriptionBridge : public MTRDishwasherAlarmLatchAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmLatchAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmLatchAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmLatchAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmLatchAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + +class MTRDishwasherAlarmStateAttributeCallbackBridge : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, chip::BitMask value); +}; + +class MTRDishwasherAlarmStateAttributeCallbackSubscriptionBridge : public MTRDishwasherAlarmStateAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmStateAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmStateAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmStateAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + +class MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge + : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); +}; + +class MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge + : public MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + +class MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge + : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); +}; + +class MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge + : public MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge( + dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + +class MTRDishwasherAlarmEventListListAttributeCallbackBridge + : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmEventListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmEventListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); +}; + +class MTRDishwasherAlarmEventListListAttributeCallbackSubscriptionBridge + : public MTRDishwasherAlarmEventListListAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmEventListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmEventListListAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmEventListListAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmEventListListAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + +class MTRDishwasherAlarmAttributeListListAttributeCallbackBridge + : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList & value); +}; + +class MTRDishwasherAlarmAttributeListListAttributeCallbackSubscriptionBridge + : public MTRDishwasherAlarmAttributeListListAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmAttributeListListAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmAttributeListListAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmAttributeListListAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + class MTRHEPAFilterMonitoringGeneratedCommandListListAttributeCallbackBridge : public MTRCallbackBridge { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm index 5062aff3ef13eb..7a8ee8e0ec11e1 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm @@ -8853,6 +8853,227 @@ } } +void MTRDishwasherAlarmMaskAttributeCallbackBridge::OnSuccessFn( + void * context, chip::BitMask value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedInt:value.Raw()]; + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmMaskAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + +void MTRDishwasherAlarmLatchAttributeCallbackBridge::OnSuccessFn( + void * context, chip::BitMask value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedInt:value.Raw()]; + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmLatchAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + +void MTRDishwasherAlarmStateAttributeCallbackBridge::OnSuccessFn( + void * context, chip::BitMask value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedInt:value.Raw()]; + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmStateAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + +void MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::DecodableList & value) +{ + NSArray * _Nonnull objCValue; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = value.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + OnFailureFn(context, err); + return; + } + objCValue = array_0; + } + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + +void MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::DecodableList & value) +{ + NSArray * _Nonnull objCValue; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = value.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + OnFailureFn(context, err); + return; + } + objCValue = array_0; + } + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmAcceptedCommandListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + +void MTRDishwasherAlarmEventListListAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::DecodableList & value) +{ + NSArray * _Nonnull objCValue; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = value.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + OnFailureFn(context, err); + return; + } + objCValue = array_0; + } + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmEventListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + +void MTRDishwasherAlarmAttributeListListAttributeCallbackBridge::OnSuccessFn( + void * context, const chip::app::DataModel::DecodableList & value) +{ + NSArray * _Nonnull objCValue; + { // Scope for our temporary variables + auto * array_0 = [NSMutableArray new]; + auto iter_0 = value.begin(); + while (iter_0.Next()) { + auto & entry_0 = iter_0.GetValue(); + NSNumber * newElement_0; + newElement_0 = [NSNumber numberWithUnsignedInt:entry_0]; + [array_0 addObject:newElement_0]; + } + CHIP_ERROR err = iter_0.GetStatus(); + if (err != CHIP_NO_ERROR) { + OnFailureFn(context, err); + return; + } + objCValue = array_0; + } + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmAttributeListListAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + void MTRHEPAFilterMonitoringGeneratedCommandListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index be9c55ebba0266..619cb7cbfee0a0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -280,6 +280,7 @@ typedef NS_ENUM(uint32_t, MTRClusterIDType) { MTRClusterIDTypeRefrigeratorAlarmID MTR_NEWLY_AVAILABLE = 0x00000057, MTRClusterIDTypeAirQualityID MTR_NEWLY_AVAILABLE = 0x0000005B, MTRClusterIDTypeSmokeCOAlarmID MTR_NEWLY_AVAILABLE = 0x0000005C, + MTRClusterIDTypeDishwasherAlarmID MTR_NEWLY_AVAILABLE = 0x0000005D, MTRClusterIDTypeHEPAFilterMonitoringID MTR_NEWLY_AVAILABLE = 0x00000071, MTRClusterIDTypeActivatedCarbonFilterMonitoringID MTR_NEWLY_AVAILABLE = 0x00000072, MTRClusterIDTypeCeramicFilterMonitoringID MTR_NEWLY_AVAILABLE = 0x00000073, @@ -3803,6 +3804,22 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterSmokeCOAlarmAttributeClusterRevisionID MTR_NEWLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster DishwasherAlarm attributes + MTRAttributeIDTypeClusterDishwasherAlarmAttributeMaskID MTR_NEWLY_AVAILABLE = 0x00000000, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeLatchID MTR_NEWLY_AVAILABLE = 0x00000001, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeStateID MTR_NEWLY_AVAILABLE = 0x00000002, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeGeneratedCommandListID MTR_NEWLY_AVAILABLE + = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeAcceptedCommandListID MTR_NEWLY_AVAILABLE + = MTRAttributeIDTypeGlobalAttributeAcceptedCommandListID, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeEventListID MTR_NEWLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeEventListID, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeAttributeListID MTR_NEWLY_AVAILABLE + = MTRAttributeIDTypeGlobalAttributeAttributeListID, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeFeatureMapID MTR_NEWLY_AVAILABLE + = MTRAttributeIDTypeGlobalAttributeFeatureMapID, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeClusterRevisionID MTR_NEWLY_AVAILABLE + = MTRAttributeIDTypeGlobalAttributeClusterRevisionID, + // Cluster HEPAFilterMonitoring attributes MTRAttributeIDTypeClusterHEPAFilterMonitoringAttributeConditionID MTR_NEWLY_AVAILABLE = 0x00000000, MTRAttributeIDTypeClusterHEPAFilterMonitoringAttributeDegradationDirectionID MTR_NEWLY_AVAILABLE = 0x00000001, @@ -9155,6 +9172,9 @@ typedef NS_ENUM(uint32_t, MTRCommandIDType) { // Cluster SmokeCOAlarm commands MTRCommandIDTypeClusterSmokeCOAlarmCommandSelfTestRequestID MTR_NEWLY_AVAILABLE = 0x00000000, + // Cluster DishwasherAlarm commands + MTRCommandIDTypeClusterDishwasherAlarmCommandResetID MTR_NEWLY_AVAILABLE = 0x00000000, + // Cluster HEPAFilterMonitoring commands MTRCommandIDTypeClusterHEPAFilterMonitoringCommandResetConditionID MTR_NEWLY_AVAILABLE = 0x00000000, @@ -10325,6 +10345,9 @@ typedef NS_ENUM(uint32_t, MTREventIDType) { MTREventIDTypeClusterSmokeCOAlarmEventInterconnectCOAlarmID MTR_NEWLY_AVAILABLE = 0x00000009, MTREventIDTypeClusterSmokeCOAlarmEventAllClearID MTR_NEWLY_AVAILABLE = 0x0000000A, + // Cluster DishwasherAlarm events + MTREventIDTypeClusterDishwasherAlarmEventNotifyID MTR_NEWLY_AVAILABLE = 0x00000000, + // Cluster DoorLock deprecated event names MTRClusterDoorLockEventDoorLockAlarmID MTR_DEPRECATED("Please use MTREventIDTypeClusterDoorLockEventDoorLockAlarmID", ios(16.1, 16.4), macos(13.0, 13.3), watchos(9.1, 9.4), tvos(16.1, 16.4)) diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h index bd0145b4079a35..00cee2c025ec8d 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h @@ -2981,6 +2981,50 @@ MTR_NEWLY_AVAILABLE @end +/** + * Cluster Dishwasher Alarm + * Attributes and commands for configuring the Dishwasher alarm. + */ +MTR_NEWLY_AVAILABLE +@interface MTRClusterDishwasherAlarm : MTRCluster + +- (instancetype _Nullable)initWithDevice:(MTRDevice *)device + endpointID:(NSNumber *)endpointID + queue:(dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER MTR_NEWLY_AVAILABLE; + +- (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params + expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries + expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs + completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeMaskWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; +- (void)writeAttributeMaskWithValue:(NSDictionary *)dataValueDictionary + expectedValueInterval:(NSNumber *)expectedValueIntervalMs MTR_NEWLY_AVAILABLE; +- (void)writeAttributeMaskWithValue:(NSDictionary *)dataValueDictionary + expectedValueInterval:(NSNumber *)expectedValueIntervalMs + params:(MTRWriteParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeLatchWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeStateWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (NSDictionary *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + +- (instancetype)init NS_UNAVAILABLE; ++ (instancetype)new NS_UNAVAILABLE; + +@end + /** * Cluster HEPA Filter Monitoring * Attributes and commands for monitoring HEPA filters in a device diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm index 940b70222f5bdc..14532dfed366c0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm @@ -13638,6 +13638,186 @@ - (void)writeAttributeSensitivityLevelWithValue:(NSDictionary *) @end +@implementation MTRClusterDishwasherAlarm + +- (instancetype)initWithDevice:(MTRDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue +{ + if (self = [super initWithQueue:queue]) { + if (device == nil) { + return nil; + } + + _endpoint = [endpointID unsignedShortValue]; + _device = device; + } + return self; +} + +- (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params + expectedValues:(NSArray *> *)expectedValues + expectedValueInterval:(NSNumber *)expectedValueIntervalMs + completion:(MTRStatusCompletion)completion +{ + NSString * logPrefix = [NSString stringWithFormat:@"MTRDevice command %u %u %u %u", self.device.deviceController.fabricIndex, + _endpoint, (unsigned int) MTRClusterIDTypeDishwasherAlarmID, + (unsigned int) MTRCommandIDTypeClusterDishwasherAlarmCommandResetID]; + // Make a copy of params before we go async. + params = [params copy]; + NSNumber * timedInvokeTimeoutMsParam = params.timedInvokeTimeoutMs; + if (timedInvokeTimeoutMsParam) { + timedInvokeTimeoutMsParam = MTRClampedNumber(timedInvokeTimeoutMsParam, @(1), @(UINT16_MAX)); + } + MTRAsyncCallbackQueueWorkItem * workItem = [[MTRAsyncCallbackQueueWorkItem alloc] initWithQueue:self.device.queue]; + MTRAsyncCallbackReadyHandler readyHandler = ^(MTRDevice * device, NSUInteger retryCount) { + MTRClustersLogDequeue(logPrefix, self.device.asyncCallbackWorkQueue); + MTRBaseDevice * baseDevice = [[MTRBaseDevice alloc] initWithNodeID:self.device.nodeID + controller:self.device.deviceController]; + auto * bridge = new MTRCommandSuccessCallbackBridge( + self.device.queue, + ^(id _Nullable value, NSError * _Nullable error) { + MTRClustersLogCompletion(logPrefix, value, error); + dispatch_async(self.callbackQueue, ^{ + completion(error); + }); + [workItem endWork]; + }, + ^(ExchangeManager & exchangeManager, const SessionHandle & session, CommandSuccessCallbackType successCb, + MTRErrorCallback failureCb, MTRCallbackBridgeBase * bridge) { + auto * typedBridge = static_cast(bridge); + Optional timedInvokeTimeoutMs; + Optional invokeTimeout; + ListFreer listFreer; + DishwasherAlarm::Commands::Reset::Type request; + if (timedInvokeTimeoutMsParam != nil) { + timedInvokeTimeoutMs.SetValue(timedInvokeTimeoutMsParam.unsignedShortValue); + } + if (params != nil) { + if (params.serverSideProcessingTimeout != nil) { + // Clamp to a number of seconds that will not overflow 32-bit + // int when converted to ms. + auto * serverSideProcessingTimeout + = MTRClampedNumber(params.serverSideProcessingTimeout, @(0), @(UINT16_MAX)); + invokeTimeout.SetValue(Seconds16(serverSideProcessingTimeout.unsignedShortValue)); + } + } + request.alarms = static_cast>(params.alarms.unsignedIntValue); + if (params.mask != nil) { + auto & definedValue_0 = request.mask.Emplace(); + definedValue_0 = static_cast>(params.mask.unsignedIntValue); + } + + return MTRStartInvokeInteraction(typedBridge, request, exchangeManager, session, successCb, failureCb, + self->_endpoint, timedInvokeTimeoutMs, invokeTimeout); + }); + std::move(*bridge).DispatchAction(baseDevice); + }; + workItem.readyHandler = readyHandler; + MTRClustersLogEnqueue(logPrefix, self.device.asyncCallbackWorkQueue); + [self.device.asyncCallbackWorkQueue enqueueWorkItem:workItem]; + + if (!expectedValueIntervalMs || ([expectedValueIntervalMs compare:@(0)] == NSOrderedAscending)) { + expectedValues = nil; + } else { + expectedValueIntervalMs = MTRClampedNumber(expectedValueIntervalMs, @(1), @(UINT32_MAX)); + } + if (expectedValues) { + [self.device setExpectedValues:expectedValues expectedValueInterval:expectedValueIntervalMs]; + } +} + +- (NSDictionary *)readAttributeMaskWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeMaskID) + params:params]; +} + +- (void)writeAttributeMaskWithValue:(NSDictionary *)dataValueDictionary + expectedValueInterval:(NSNumber *)expectedValueIntervalMs +{ + [self writeAttributeMaskWithValue:dataValueDictionary expectedValueInterval:expectedValueIntervalMs params:nil]; +} +- (void)writeAttributeMaskWithValue:(NSDictionary *)dataValueDictionary + expectedValueInterval:(NSNumber *)expectedValueIntervalMs + params:(MTRWriteParams * _Nullable)params +{ + NSNumber * timedWriteTimeout = params.timedWriteTimeout; + + [self.device writeAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeMaskID) + value:dataValueDictionary + expectedValueInterval:expectedValueIntervalMs + timedWriteTimeout:timedWriteTimeout]; +} + +- (NSDictionary *)readAttributeLatchWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeLatchID) + params:params]; +} + +- (NSDictionary *)readAttributeStateWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeStateID) + params:params]; +} + +- (NSDictionary *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeGeneratedCommandListID) + params:params]; +} + +- (NSDictionary *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeAcceptedCommandListID) + params:params]; +} + +- (NSDictionary *)readAttributeEventListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeEventListID) + params:params]; +} + +- (NSDictionary *)readAttributeAttributeListWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeAttributeListID) + params:params]; +} + +- (NSDictionary *)readAttributeFeatureMapWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeFeatureMapID) + params:params]; +} + +- (NSDictionary *)readAttributeClusterRevisionWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeClusterRevisionID) + params:params]; +} + +@end + @implementation MTRClusterHEPAFilterMonitoring - (instancetype)initWithDevice:(MTRDevice *)device endpointID:(NSNumber *)endpointID queue:(dispatch_queue_t)queue diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h index e483aa7dc1cbe7..6892b3e55d1722 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters_Internal.h @@ -221,6 +221,11 @@ @property (nonatomic, readonly) MTRDevice * device; @end +@interface MTRClusterDishwasherAlarm () +@property (nonatomic, readonly) uint16_t endpoint; +@property (nonatomic, readonly) MTRDevice * device; +@end + @interface MTRClusterHEPAFilterMonitoring () @property (nonatomic, readonly) uint16_t endpoint; @property (nonatomic, readonly) MTRDevice * device; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h index b0f528787d97c0..56915484735495 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h @@ -4169,6 +4169,38 @@ MTR_NEWLY_AVAILABLE @property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; @end +MTR_NEWLY_AVAILABLE +@interface MTRDishwasherAlarmClusterResetParams : NSObject + +@property (nonatomic, copy) NSNumber * _Nonnull alarms MTR_NEWLY_AVAILABLE; + +@property (nonatomic, copy) NSNumber * _Nullable mask MTR_NEWLY_AVAILABLE; +/** + * Controls whether the command is a timed command (using Timed Invoke). + * + * If nil (the default value), a regular invoke is done for commands that do + * not require a timed invoke and a timed invoke with some default timed request + * timeout is done for commands that require a timed invoke. + * + * If not nil, a timed invoke is done, with the provided value used as the timed + * request timeout. The value should be chosen small enough to provide the + * desired security properties but large enough that it will allow a round-trip + * from the sever to the client (for the status response and actual invoke + * request) within the timeout window. + * + */ +@property (nonatomic, copy, nullable) NSNumber * timedInvokeTimeoutMs; + +/** + * Controls how much time, in seconds, we will allow for the server to process the command. + * + * The command will then time out if that much time, plus an allowance for retransmits due to network failures, passes. + * + * If nil, the framework will try to select an appropriate timeout value itself. + */ +@property (nonatomic, copy, nullable) NSNumber * serverSideProcessingTimeout; +@end + MTR_NEWLY_AVAILABLE @interface MTRHEPAFilterMonitoringClusterResetConditionParams : NSObject /** diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm index 5e9e298fa5b733..66b083390e4eab 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm @@ -6553,6 +6553,40 @@ - (NSString *)description return descriptionString; } +@end +@implementation MTRDishwasherAlarmClusterResetParams +- (instancetype)init +{ + if (self = [super init]) { + + _alarms = @(0); + + _mask = nil; + _timedInvokeTimeoutMs = nil; + _serverSideProcessingTimeout = nil; + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone; +{ + auto other = [[MTRDishwasherAlarmClusterResetParams alloc] init]; + + other.alarms = self.alarms; + other.mask = self.mask; + other.timedInvokeTimeoutMs = self.timedInvokeTimeoutMs; + other.serverSideProcessingTimeout = self.serverSideProcessingTimeout; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = + [NSString stringWithFormat:@"<%@: alarms:%@; mask:%@; >", NSStringFromClass([self class]), _alarms, _mask]; + return descriptionString; +} + @end @implementation MTRHEPAFilterMonitoringClusterResetConditionParams - (instancetype)init diff --git a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm index 3e1a0cb177f531..58458104cf5aa0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTREventTLVValueDecoder.mm @@ -1752,6 +1752,50 @@ static id _Nullable DecodeEventPayloadForSmokeCOAlarmCluster(EventId aEventId, T *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; return nil; } +static id _Nullable DecodeEventPayloadForDishwasherAlarmCluster(EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) +{ + using namespace Clusters::DishwasherAlarm; + switch (aEventId) { + case Events::Notify::Id: { + Events::Notify::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + + __auto_type * value = [MTRDishwasherAlarmClusterNotifyEvent new]; + + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedInt:cppValue.active.Raw()]; + value.active = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedInt:cppValue.inactive.Raw()]; + value.inactive = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedInt:cppValue.state.Raw()]; + value.state = memberValue; + } while (0); + do { + NSNumber * _Nonnull memberValue; + memberValue = [NSNumber numberWithUnsignedInt:cppValue.mask.Raw()]; + value.mask = memberValue; + } while (0); + + return value; + } + default: { + break; + } + } + + *aError = CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB; + return nil; +} static id _Nullable DecodeEventPayloadForHEPAFilterMonitoringCluster( EventId aEventId, TLV::TLVReader & aReader, CHIP_ERROR * aError) { @@ -2942,6 +2986,9 @@ id _Nullable MTRDecodeEventPayload(const ConcreteEventPath & aPath, TLV::TLVRead case Clusters::SmokeCoAlarm::Id: { return DecodeEventPayloadForSmokeCOAlarmCluster(aPath.mEventId, aReader, aError); } + case Clusters::DishwasherAlarm::Id: { + return DecodeEventPayloadForDishwasherAlarmCluster(aPath.mEventId, aReader, aError); + } case Clusters::HepaFilterMonitoring::Id: { return DecodeEventPayloadForHEPAFilterMonitoringCluster(aPath.mEventId, aReader, aError); } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h index fa0842de1b7f15..f8754e31390a39 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.h @@ -737,6 +737,14 @@ MTR_NEWLY_AVAILABLE @interface MTRSmokeCOAlarmClusterAllClearEvent : NSObject @end +MTR_NEWLY_AVAILABLE +@interface MTRDishwasherAlarmClusterNotifyEvent : NSObject +@property (nonatomic, copy) NSNumber * _Nonnull active MTR_NEWLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull inactive MTR_NEWLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull state MTR_NEWLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull mask MTR_NEWLY_AVAILABLE; +@end + API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)) @interface MTRDoorLockClusterCredentialStruct : NSObject @property (nonatomic, copy) NSNumber * _Nonnull credentialType API_AVAILABLE(ios(16.4), macos(13.3), watchos(9.4), tvos(16.4)); diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm index f34a16a25558db..2347d78a69a8c8 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRStructsObjc.mm @@ -2988,6 +2988,43 @@ - (NSString *)description @end +@implementation MTRDishwasherAlarmClusterNotifyEvent +- (instancetype)init +{ + if (self = [super init]) { + + _active = @(0); + + _inactive = @(0); + + _state = @(0); + + _mask = @(0); + } + return self; +} + +- (id)copyWithZone:(NSZone * _Nullable)zone +{ + auto other = [[MTRDishwasherAlarmClusterNotifyEvent alloc] init]; + + other.active = self.active; + other.inactive = self.inactive; + other.state = self.state; + other.mask = self.mask; + + return other; +} + +- (NSString *)description +{ + NSString * descriptionString = [NSString stringWithFormat:@"<%@: active:%@; inactive:%@; state:%@; mask:%@; >", + NSStringFromClass([self class]), _active, _inactive, _state, _mask]; + return descriptionString; +} + +@end + @implementation MTRDoorLockClusterCredentialStruct - (instancetype)init { diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp index a84a46bd004e6b..adb61dd7207c0c 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp @@ -8133,6 +8133,167 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) } // namespace Attributes } // namespace SmokeCoAlarm +namespace DishwasherAlarm { +namespace Attributes { + +namespace Mask { + +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace Mask + +namespace Latch { + +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace Latch + +namespace State { + +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace State + +namespace FeatureMap { + +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace FeatureMap + +namespace ClusterRevision { + +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value) +{ + using Traits = NumericAttributeTraits; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value) +{ + using Traits = NumericAttributeTraits; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_INT16U_ATTRIBUTE_TYPE); +} + +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace DishwasherAlarm + namespace HepaFilterMonitoring { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h index b7d0c6fea1c4b9..42d554ea610679 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h @@ -1551,6 +1551,37 @@ EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Attributes } // namespace SmokeCoAlarm +namespace DishwasherAlarm { +namespace Attributes { + +namespace Mask { +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value); // AlarmMap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace Mask + +namespace Latch { +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value); // AlarmMap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace Latch + +namespace State { +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value); // AlarmMap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace State + +namespace FeatureMap { +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); +} // namespace FeatureMap + +namespace ClusterRevision { +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace DishwasherAlarm + namespace HepaFilterMonitoring { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h index 0b6e6773814610..7c7a3f0df9f485 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -401,6 +401,14 @@ void emberAfAirQualityClusterInitCallback(chip::EndpointId endpoint); */ void emberAfSmokeCoAlarmClusterInitCallback(chip::EndpointId endpoint); +/** @brief Dishwasher Alarm Cluster Init + * + * Cluster Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfDishwasherAlarmClusterInitCallback(chip::EndpointId endpoint); + /** @brief HEPA Filter Monitoring Cluster Init * * Cluster Init @@ -4286,6 +4294,84 @@ void emberAfSmokeCoAlarmClusterServerTickCallback(chip::EndpointId endpoint); */ void emberAfSmokeCoAlarmClusterClientTickCallback(chip::EndpointId endpoint); +// +// Dishwasher Alarm Cluster +// + +/** @brief Dishwasher Alarm Cluster Server Init + * + * Server Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfDishwasherAlarmClusterServerInitCallback(chip::EndpointId endpoint); + +/** @brief Dishwasher Alarm Cluster Server Shutdown + * + * Server Shutdown + * + * @param endpoint Endpoint that is being shutdown + */ +void MatterDishwasherAlarmClusterServerShutdownCallback(chip::EndpointId endpoint); + +/** @brief Dishwasher Alarm Cluster Client Init + * + * Client Init + * + * @param endpoint Endpoint that is being initialized + */ +void emberAfDishwasherAlarmClusterClientInitCallback(chip::EndpointId endpoint); + +/** @brief Dishwasher Alarm Cluster Server Attribute Changed + * + * Server Attribute Changed + * + * @param attributePath Concrete attribute path that changed + */ +void MatterDishwasherAlarmClusterServerAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath); + +/** @brief Dishwasher Alarm Cluster Server Pre Attribute Changed + * + * Server Pre Attribute Changed + * + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status +MatterDishwasherAlarmClusterServerPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath, + EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** @brief Dishwasher Alarm Cluster Client Pre Attribute Changed + * + * Client Pre Attribute Changed + * + * @param attributePath Concrete attribute path to be changed + * @param attributeType Attribute type + * @param size Attribute size + * @param value Attribute value + */ +chip::Protocols::InteractionModel::Status +MatterDishwasherAlarmClusterClientPreAttributeChangedCallback(const chip::app::ConcreteAttributePath & attributePath, + EmberAfAttributeType attributeType, uint16_t size, uint8_t * value); + +/** @brief Dishwasher Alarm Cluster Server Tick + * + * Server Tick + * + * @param endpoint Endpoint that is being served + */ +void emberAfDishwasherAlarmClusterServerTickCallback(chip::EndpointId endpoint); + +/** @brief Dishwasher Alarm Cluster Client Tick + * + * Client Tick + * + * @param endpoint Endpoint that is being served + */ +void emberAfDishwasherAlarmClusterClientTickCallback(chip::EndpointId endpoint); + // // HEPA Filter Monitoring Cluster // @@ -8038,6 +8124,12 @@ bool emberAfRefrigeratorAlarmClusterResetCallback( bool emberAfSmokeCoAlarmClusterSelfTestRequestCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::DecodableType & commandData); +/** + * @brief Dishwasher Alarm Cluster Reset Command callback (from client) + */ +bool emberAfDishwasherAlarmClusterResetCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::DishwasherAlarm::Commands::Reset::DecodableType & commandData); /** * @brief HEPA Filter Monitoring Cluster ResetCondition Command callback (from client) */ diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index e950636dd0e8c5..b135e682178c77 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -1649,6 +1649,20 @@ enum class Feature : uint32_t }; } // namespace SmokeCoAlarm +namespace DishwasherAlarm { + +// Bitmap for AlarmMap +enum class AlarmMap : uint32_t +{ + kInflowError = 0x1, + kDrainError = 0x2, + kDoorError = 0x4, + kTempTooLow = 0x8, + kTempTooHigh = 0x10, + kWaterLevelError = 0x11, +}; +} // namespace DishwasherAlarm + namespace HepaFilterMonitoring { // Enum for ChangeIndicationEnum diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index dcb81394d725f3..50545336fe260e 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -12220,6 +12220,145 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) } // namespace Events } // namespace SmokeCoAlarm +namespace DishwasherAlarm { + +namespace Commands { +namespace Reset { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kAlarms), alarms)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kMask), mask)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVType outer; + VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE); + ReturnErrorOnFailure(reader.EnterContainer(outer)); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + if (!TLV::IsContextTag(reader.GetTag())) + { + continue; + } + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kAlarms): + ReturnErrorOnFailure(DataModel::Decode(reader, alarms)); + break; + case to_underlying(Fields::kMask): + ReturnErrorOnFailure(DataModel::Decode(reader, mask)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace Reset. +} // namespace Commands + +namespace Attributes { +CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path) +{ + switch (path.mAttributeId) + { + case Attributes::Mask::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, mask)); + break; + case Attributes::Latch::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, latch)); + break; + case Attributes::State::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, state)); + break; + case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, generatedCommandList)); + break; + case Attributes::AcceptedCommandList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, acceptedCommandList)); + break; + case Attributes::EventList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, eventList)); + break; + case Attributes::AttributeList::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, attributeList)); + break; + case Attributes::FeatureMap::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, featureMap)); + break; + case Attributes::ClusterRevision::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, clusterRevision)); + break; + default: + break; + } + + return CHIP_NO_ERROR; +} +} // namespace Attributes + +namespace Events { +namespace Notify { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kActive), active)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kInactive), inactive)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kState), state)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(Fields::kMask), mask)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVType outer; + VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE); + ReturnErrorOnFailure(reader.EnterContainer(outer)); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + if (!TLV::IsContextTag(reader.GetTag())) + { + continue; + } + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kActive): + ReturnErrorOnFailure(DataModel::Decode(reader, active)); + break; + case to_underlying(Fields::kInactive): + ReturnErrorOnFailure(DataModel::Decode(reader, inactive)); + break; + case to_underlying(Fields::kState): + ReturnErrorOnFailure(DataModel::Decode(reader, state)); + break; + case to_underlying(Fields::kMask): + ReturnErrorOnFailure(DataModel::Decode(reader, mask)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace Notify. +} // namespace Events + +} // namespace DishwasherAlarm namespace HepaFilterMonitoring { namespace Commands { @@ -24145,6 +24284,13 @@ bool CommandIsFabricScoped(ClusterId aCluster, CommandId aCommand) return false; } } + case Clusters::DishwasherAlarm::Id: { + switch (aCommand) + { + default: + return false; + } + } case Clusters::HepaFilterMonitoring::Id: { switch (aCommand) { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 5b3532d8d28375..dd083e917e11b4 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -15267,6 +15267,199 @@ struct DecodableType } // namespace AllClear } // namespace Events } // namespace SmokeCoAlarm +namespace DishwasherAlarm { + +namespace Commands { +// Forward-declarations so we can reference these later. + +namespace Reset { +struct Type; +struct DecodableType; +} // namespace Reset + +} // namespace Commands + +namespace Commands { +namespace Reset { +enum class Fields : uint8_t +{ + kAlarms = 0, + kMask = 1, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::Reset::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + + chip::BitMask alarms = static_cast>(0); + Optional> mask; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; + + using ResponseType = DataModel::NullObjectType; + + static constexpr bool MustUseTimedInvoke() { return false; } +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::Reset::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + + chip::BitMask alarms = static_cast>(0); + Optional> mask; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace Reset +} // namespace Commands + +namespace Attributes { + +namespace Mask { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Mask::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace Mask +namespace Latch { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Latch::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace Latch +namespace State { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::State::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace State +namespace GeneratedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } +}; +} // namespace GeneratedCommandList +namespace AcceptedCommandList { +struct TypeInfo : public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } +}; +} // namespace AcceptedCommandList +namespace EventList { +struct TypeInfo : public Clusters::Globals::Attributes::EventList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } +}; +} // namespace EventList +namespace AttributeList { +struct TypeInfo : public Clusters::Globals::Attributes::AttributeList::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } +}; +} // namespace AttributeList +namespace FeatureMap { +struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } +}; +} // namespace FeatureMap +namespace ClusterRevision { +struct TypeInfo : public Clusters::Globals::Attributes::ClusterRevision::TypeInfo +{ + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } +}; +} // namespace ClusterRevision + +struct TypeInfo +{ + struct DecodableType + { + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + + CHIP_ERROR Decode(TLV::TLVReader & reader, const ConcreteAttributePath & path); + + Attributes::Mask::TypeInfo::DecodableType mask = + static_cast>(0); + Attributes::Latch::TypeInfo::DecodableType latch = + static_cast>(0); + Attributes::State::TypeInfo::DecodableType state = + static_cast>(0); + Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; + Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; + Attributes::EventList::TypeInfo::DecodableType eventList; + Attributes::AttributeList::TypeInfo::DecodableType attributeList; + Attributes::FeatureMap::TypeInfo::DecodableType featureMap = static_cast(0); + Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision = static_cast(0); + }; +}; +} // namespace Attributes +namespace Events { +namespace Notify { +static constexpr PriorityLevel kPriorityLevel = PriorityLevel::Info; + +enum class Fields : uint8_t +{ + kActive = 0, + kInactive = 1, + kState = 2, + kMask = 3, +}; + +struct Type +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::Notify::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + static constexpr bool kIsFabricScoped = false; + + chip::BitMask active = static_cast>(0); + chip::BitMask inactive = static_cast>(0); + chip::BitMask state = static_cast>(0); + chip::BitMask mask = static_cast>(0); + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; +}; + +struct DecodableType +{ +public: + static constexpr PriorityLevel GetPriorityLevel() { return kPriorityLevel; } + static constexpr EventId GetEventId() { return Events::Notify::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + + chip::BitMask active = static_cast>(0); + chip::BitMask inactive = static_cast>(0); + chip::BitMask state = static_cast>(0); + chip::BitMask mask = static_cast>(0); + + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +} // namespace Notify +} // namespace Events +} // namespace DishwasherAlarm namespace HepaFilterMonitoring { namespace Commands { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h index d4e77a9d48c17a..fae80e45d48db6 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h @@ -2667,6 +2667,48 @@ static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; } // namespace Attributes } // namespace SmokeCoAlarm +namespace DishwasherAlarm { +namespace Attributes { + +namespace Mask { +static constexpr AttributeId Id = 0x00000000; +} // namespace Mask + +namespace Latch { +static constexpr AttributeId Id = 0x00000001; +} // namespace Latch + +namespace State { +static constexpr AttributeId Id = 0x00000002; +} // namespace State + +namespace GeneratedCommandList { +static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id; +} // namespace GeneratedCommandList + +namespace AcceptedCommandList { +static constexpr AttributeId Id = Globals::Attributes::AcceptedCommandList::Id; +} // namespace AcceptedCommandList + +namespace EventList { +static constexpr AttributeId Id = Globals::Attributes::EventList::Id; +} // namespace EventList + +namespace AttributeList { +static constexpr AttributeId Id = Globals::Attributes::AttributeList::Id; +} // namespace AttributeList + +namespace FeatureMap { +static constexpr AttributeId Id = Globals::Attributes::FeatureMap::Id; +} // namespace FeatureMap + +namespace ClusterRevision { +static constexpr AttributeId Id = Globals::Attributes::ClusterRevision::Id; +} // namespace ClusterRevision + +} // namespace Attributes +} // namespace DishwasherAlarm + namespace HepaFilterMonitoring { namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h index ba75dc46137530..091d766a3cee86 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Clusters.h @@ -163,6 +163,9 @@ static constexpr ClusterId Id = 0x0000005B; namespace SmokeCoAlarm { static constexpr ClusterId Id = 0x0000005C; } // namespace SmokeCoAlarm +namespace DishwasherAlarm { +static constexpr ClusterId Id = 0x0000005D; +} // namespace DishwasherAlarm namespace HepaFilterMonitoring { static constexpr ClusterId Id = 0x00000071; } // namespace HepaFilterMonitoring diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h index 9470493c02717a..cef964c6ef9356 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h @@ -671,6 +671,16 @@ static constexpr CommandId Id = 0x00000000; } // namespace Commands } // namespace SmokeCoAlarm +namespace DishwasherAlarm { +namespace Commands { + +namespace Reset { +static constexpr CommandId Id = 0x00000000; +} // namespace Reset + +} // namespace Commands +} // namespace DishwasherAlarm + namespace HepaFilterMonitoring { namespace Commands { diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h index 91ec9c29157909..9c20b1b268e32f 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Events.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Events.h @@ -327,6 +327,16 @@ static constexpr EventId Id = 0x0000000A; } // namespace Events } // namespace SmokeCoAlarm +namespace DishwasherAlarm { +namespace Events { + +namespace Notify { +static constexpr EventId Id = 0x00000000; +} // namespace Notify + +} // namespace Events +} // namespace DishwasherAlarm + namespace DoorLock { namespace Events { diff --git a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h index 6807688ee25204..88c0fe527db84a 100644 --- a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h +++ b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h @@ -316,6 +316,12 @@ #define CHIP_PRINTCLUSTER_SMOKE_CO_ALARM_CLUSTER #endif +#if defined(ZCL_USING_DISHWASHER_ALARM_SERVER) || defined(ZCL_USING_DISHWASHER_ALARM_CLIENT) +#define CHIP_PRINTCLUSTER_DISHWASHER_ALARM { chip::app::Clusters::DishwasherAlarm::Id, "Dishwasher Alarm" }, +#else +#define CHIP_PRINTCLUSTER_DISHWASHER_ALARM +#endif + #if defined(ZCL_USING_HEPA_FILTER_MONITORING_CLUSTER_SERVER) || defined(ZCL_USING_HEPA_FILTER_MONITORING_CLUSTER_CLIENT) #define CHIP_PRINTCLUSTER_HEPA_FILTER_MONITORING_CLUSTER \ { chip::app::Clusters::HepaFilterMonitoring::Id, "HEPA Filter Monitoring" }, @@ -635,6 +641,7 @@ CHIP_PRINTCLUSTER_REFRIGERATOR_ALARM \ CHIP_PRINTCLUSTER_AIR_QUALITY_CLUSTER \ CHIP_PRINTCLUSTER_SMOKE_CO_ALARM_CLUSTER \ + CHIP_PRINTCLUSTER_DISHWASHER_ALARM \ CHIP_PRINTCLUSTER_HEPA_FILTER_MONITORING_CLUSTER \ CHIP_PRINTCLUSTER_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER \ CHIP_PRINTCLUSTER_CERAMIC_FILTER_MONITORING_CLUSTER \ diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 0ac52bfce3ae98..d3d52007a041b4 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -78,6 +78,7 @@ | RefrigeratorAlarm | 0x0057 | | AirQuality | 0x005B | | SmokeCoAlarm | 0x005C | +| DishwasherAlarm | 0x005D | | HepaFilterMonitoring | 0x0071 | | ActivatedCarbonFilterMonitoring | 0x0072 | | CeramicFilterMonitoring | 0x0073 | @@ -4233,6 +4234,58 @@ class SmokeCoAlarmSelfTestRequest : public ClusterCommand chip::app::Clusters::SmokeCoAlarm::Commands::SelfTestRequest::Type mRequest; }; +/*----------------------------------------------------------------------------*\ +| Cluster DishwasherAlarm | 0x005D | +|------------------------------------------------------------------------------| +| Commands: | | +| * Reset | 0x00 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * Mask | 0x0000 | +| * Latch | 0x0001 | +| * State | 0x0002 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +| * Notify | 0x0000 | +\*----------------------------------------------------------------------------*/ + +/* + * Command Reset + */ +class DishwasherAlarmReset : public ClusterCommand +{ +public: + DishwasherAlarmReset(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("reset", credsIssuerConfig) + { + AddArgument("Alarms", 0, UINT32_MAX, &mRequest.alarms); + AddArgument("Mask", 0, UINT32_MAX, &mRequest.mask); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(chip::DeviceProxy * device, std::vector endpointIds) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) command (0x00000000) on endpoint %u", endpointIds.at(0)); + + return ClusterCommand::SendCommand(device, endpointIds.at(0), 0x0000005D, 0x00000000, mRequest); + } + + CHIP_ERROR SendGroupCommand(chip::GroupId groupId, chip::FabricIndex fabricIndex) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) command (0x00000000) on Group %u", groupId); + + return ClusterCommand::SendGroupCommand(groupId, fabricIndex, 0x0000005D, 0x00000000, mRequest); + } + +private: + chip::app::Clusters::DishwasherAlarm::Commands::Reset::Type mRequest; +}; + /*----------------------------------------------------------------------------*\ | Cluster HepaFilterMonitoring | 0x0071 | |------------------------------------------------------------------------------| @@ -13364,6 +13417,72 @@ void registerClusterSmokeCoAlarm(Commands & commands, CredentialIssuerCommands * commands.Register(clusterName, clusterCommands); } +void registerClusterDishwasherAlarm(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) +{ + using namespace chip::app::Clusters::DishwasherAlarm; + + const char * clusterName = "DishwasherAlarm"; + + commands_list clusterCommands = { + // + // Commands + // + make_unique(Id, credsIssuerConfig), // + make_unique(credsIssuerConfig), // + // + // Attributes + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "mask", Attributes::Mask::Id, credsIssuerConfig), // + make_unique(Id, "latch", Attributes::Latch::Id, credsIssuerConfig), // + make_unique(Id, "state", Attributes::State::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + make_unique>(Id, credsIssuerConfig), // + make_unique>>( + Id, "mask", 0, UINT32_MAX, Attributes::Mask::Id, WriteCommandType::kWrite, credsIssuerConfig), // + make_unique>>( + Id, "latch", 0, UINT32_MAX, Attributes::Latch::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "state", 0, UINT32_MAX, Attributes::State::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite, + credsIssuerConfig), // + make_unique>>( + Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "event-list", Attributes::EventList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "attribute-list", Attributes::AttributeList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "feature-map", 0, UINT32_MAX, Attributes::FeatureMap::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>(Id, "cluster-revision", 0, UINT16_MAX, Attributes::ClusterRevision::Id, + WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "mask", Attributes::Mask::Id, credsIssuerConfig), // + make_unique(Id, "latch", Attributes::Latch::Id, credsIssuerConfig), // + make_unique(Id, "state", Attributes::State::Id, credsIssuerConfig), // + make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // + make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // + make_unique(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), // + make_unique(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), // + make_unique(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), // + // + // Events + // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "notify", Events::Notify::Id, credsIssuerConfig), // + make_unique(Id, credsIssuerConfig), // + make_unique(Id, "notify", Events::Notify::Id, credsIssuerConfig), // + }; + + commands.Register(clusterName, clusterCommands); +} void registerClusterHepaFilterMonitoring(Commands & commands, CredentialIssuerCommands * credsIssuerConfig) { using namespace chip::app::Clusters::HepaFilterMonitoring; @@ -18378,6 +18497,7 @@ void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssue registerClusterRefrigeratorAlarm(commands, credsIssuerConfig); registerClusterAirQuality(commands, credsIssuerConfig); registerClusterSmokeCoAlarm(commands, credsIssuerConfig); + registerClusterDishwasherAlarm(commands, credsIssuerConfig); registerClusterHepaFilterMonitoring(commands, credsIssuerConfig); registerClusterActivatedCarbonFilterMonitoring(commands, credsIssuerConfig); registerClusterCeramicFilterMonitoring(commands, credsIssuerConfig); diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp index 239d5d2d1c9660..a4d31bb42e85b7 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -3673,6 +3673,46 @@ CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const Sm return CHIP_NO_ERROR; } +CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, + const DishwasherAlarm::Events::Notify::DecodableType & value) +{ + DataModelLogger::LogString(label, indent, "{"); + { + CHIP_ERROR err = DataModelLogger::LogValue("Active", indent + 1, value.active); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Active'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("Inactive", indent + 1, value.inactive); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Inactive'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("State", indent + 1, value.state); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'State'"); + return err; + } + } + { + CHIP_ERROR err = DataModelLogger::LogValue("Mask", indent + 1, value.mask); + if (err != CHIP_NO_ERROR) + { + DataModelLogger::LogString(indent + 1, "Event truncated due to invalid value for 'Mask'"); + return err; + } + } + DataModelLogger::LogString(indent, "}"); + + return CHIP_NO_ERROR; +} CHIP_ERROR DataModelLogger::LogValue(const char * label, size_t indent, const DoorLock::Events::DoorLockAlarm::DecodableType & value) { @@ -7939,6 +7979,57 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP } break; } + case DishwasherAlarm::Id: { + switch (path.mAttributeId) + { + case DishwasherAlarm::Attributes::Mask::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("Mask", 1, value); + } + case DishwasherAlarm::Attributes::Latch::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("Latch", 1, value); + } + case DishwasherAlarm::Attributes::State::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("State", 1, value); + } + case DishwasherAlarm::Attributes::GeneratedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("GeneratedCommandList", 1, value); + } + case DishwasherAlarm::Attributes::AcceptedCommandList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AcceptedCommandList", 1, value); + } + case DishwasherAlarm::Attributes::EventList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("EventList", 1, value); + } + case DishwasherAlarm::Attributes::AttributeList::Id: { + chip::app::DataModel::DecodableList value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("AttributeList", 1, value); + } + case DishwasherAlarm::Attributes::FeatureMap::Id: { + uint32_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("FeatureMap", 1, value); + } + case DishwasherAlarm::Attributes::ClusterRevision::Id: { + uint16_t value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("ClusterRevision", 1, value); + } + } + break; + } case HepaFilterMonitoring::Id: { switch (path.mAttributeId) { @@ -13002,6 +13093,17 @@ CHIP_ERROR DataModelLogger::LogEvent(const chip::app::EventHeader & header, chip } break; } + case DishwasherAlarm::Id: { + switch (header.mPath.mEventId) + { + case DishwasherAlarm::Events::Notify::Id: { + chip::app::Clusters::DishwasherAlarm::Events::Notify::DecodableType value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("Notify", 1, value); + } + } + break; + } case DoorLock::Id: { switch (header.mPath.mEventId) { diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h index 753b6f8ed99ea1..46ab35df47172a 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.h @@ -328,6 +328,8 @@ static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::SmokeCoAlarm::Events::InterconnectCOAlarm::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::SmokeCoAlarm::Events::AllClear::DecodableType & value); +static CHIP_ERROR LogValue(const char * label, size_t indent, + const chip::app::Clusters::DishwasherAlarm::Events::Notify::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, const chip::app::Clusters::DoorLock::Events::DoorLockAlarm::DecodableType & value); static CHIP_ERROR LogValue(const char * label, size_t indent, diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h index a7411f0d9f3ec5..f488f1061df39e 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -81,6 +81,7 @@ | RefrigeratorAlarm | 0x0057 | | AirQuality | 0x005B | | SmokeCoAlarm | 0x005C | +| DishwasherAlarm | 0x005D | | HepaFilterMonitoring | 0x0071 | | ActivatedCarbonFilterMonitoring | 0x0072 | | CeramicFilterMonitoring | 0x0073 | @@ -43997,6 +43998,749 @@ class SubscribeAttributeSmokeCoAlarmClusterRevision : public SubscribeAttribute } }; +/*----------------------------------------------------------------------------*\ +| Cluster DishwasherAlarm | 0x005D | +|------------------------------------------------------------------------------| +| Commands: | | +| * Reset | 0x00 | +|------------------------------------------------------------------------------| +| Attributes: | | +| * Mask | 0x0000 | +| * Latch | 0x0001 | +| * State | 0x0002 | +| * GeneratedCommandList | 0xFFF8 | +| * AcceptedCommandList | 0xFFF9 | +| * EventList | 0xFFFA | +| * AttributeList | 0xFFFB | +| * FeatureMap | 0xFFFC | +| * ClusterRevision | 0xFFFD | +|------------------------------------------------------------------------------| +| Events: | | +| * Notify | 0x0000 | +\*----------------------------------------------------------------------------*/ + +/* + * Command Reset + */ +class DishwasherAlarmReset : public ClusterCommand { +public: + DishwasherAlarmReset() + : ClusterCommand("reset") + { + AddArgument("Alarms", 0, UINT32_MAX, &mRequest.alarms); + AddArgument("Mask", 0, UINT32_MAX, &mRequest.mask); + ClusterCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) command (0x00000000) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRDishwasherAlarmClusterResetParams alloc] init]; + params.timedInvokeTimeoutMs + = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.alarms = [NSNumber numberWithUnsignedInt:mRequest.alarms.Raw()]; + if (mRequest.mask.HasValue()) { + params.mask = [NSNumber numberWithUnsignedInt:mRequest.mask.Value().Raw()]; + } else { + params.mask = nil; + } + uint16_t repeatCount = mRepeatCount.ValueOr(1); + uint16_t __block responsesNeeded = repeatCount; + while (repeatCount--) { + [cluster resetWithParams:params + completion:^(NSError * _Nullable error) { + responsesNeeded--; + if (error != nil) { + mError = error; + LogNSError("Error", error); + } + if (responsesNeeded == 0) { + SetCommandExitStatus(mError); + } + }]; + } + return CHIP_NO_ERROR; + } + +private: + chip::app::Clusters::DishwasherAlarm::Commands::Reset::Type mRequest; +}; + +/* + * Attribute Mask + */ +class ReadDishwasherAlarmMask : public ReadAttribute { +public: + ReadDishwasherAlarmMask() + : ReadAttribute("mask") + { + } + + ~ReadDishwasherAlarmMask() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x00000000) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeMaskWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.Mask response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm Mask read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class WriteDishwasherAlarmMask : public WriteAttribute { +public: + WriteDishwasherAlarmMask() + : WriteAttribute("mask") + { + AddArgument("attr-name", "mask"); + AddArgument("attr-value", 0, UINT32_MAX, &mValue); + WriteAttribute::AddArguments(); + } + + ~WriteDishwasherAlarmMask() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) WriteAttribute (0x00000000) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRWriteParams alloc] init]; + params.timedWriteTimeout + = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; + params.dataVersion = mDataVersion.HasValue() ? [NSNumber numberWithUnsignedInt:mDataVersion.Value()] : nil; + NSNumber * _Nonnull value = [NSNumber numberWithUnsignedInt:mValue]; + + [cluster writeAttributeMaskWithValue:value + params:params + completion:^(NSError * _Nullable error) { + if (error != nil) { + LogNSError("DishwasherAlarm Mask write Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } + +private: + uint32_t mValue; +}; + +class SubscribeAttributeDishwasherAlarmMask : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmMask() + : SubscribeAttribute("mask") + { + } + + ~SubscribeAttributeDishwasherAlarmMask() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x00000000) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeMaskWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.Mask response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute Latch + */ +class ReadDishwasherAlarmLatch : public ReadAttribute { +public: + ReadDishwasherAlarmLatch() + : ReadAttribute("latch") + { + } + + ~ReadDishwasherAlarmLatch() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x00000001) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeLatchWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.Latch response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm Latch read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmLatch : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmLatch() + : SubscribeAttribute("latch") + { + } + + ~SubscribeAttributeDishwasherAlarmLatch() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x00000001) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeLatchWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.Latch response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute State + */ +class ReadDishwasherAlarmState : public ReadAttribute { +public: + ReadDishwasherAlarmState() + : ReadAttribute("state") + { + } + + ~ReadDishwasherAlarmState() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x00000002) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeStateWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.State response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm State read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmState : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmState() + : SubscribeAttribute("state") + { + } + + ~SubscribeAttributeDishwasherAlarmState() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x00000002) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeStateWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.State response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute GeneratedCommandList + */ +class ReadDishwasherAlarmGeneratedCommandList : public ReadAttribute { +public: + ReadDishwasherAlarmGeneratedCommandList() + : ReadAttribute("generated-command-list") + { + } + + ~ReadDishwasherAlarmGeneratedCommandList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x0000FFF8) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeGeneratedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.GeneratedCommandList response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm GeneratedCommandList read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmGeneratedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmGeneratedCommandList() + : SubscribeAttribute("generated-command-list") + { + } + + ~SubscribeAttributeDishwasherAlarmGeneratedCommandList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x0000FFF8) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeGeneratedCommandListWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.GeneratedCommandList response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute AcceptedCommandList + */ +class ReadDishwasherAlarmAcceptedCommandList : public ReadAttribute { +public: + ReadDishwasherAlarmAcceptedCommandList() + : ReadAttribute("accepted-command-list") + { + } + + ~ReadDishwasherAlarmAcceptedCommandList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x0000FFF9) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeAcceptedCommandListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.AcceptedCommandList response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm AcceptedCommandList read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmAcceptedCommandList : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmAcceptedCommandList() + : SubscribeAttribute("accepted-command-list") + { + } + + ~SubscribeAttributeDishwasherAlarmAcceptedCommandList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x0000FFF9) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAcceptedCommandListWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.AcceptedCommandList response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute EventList + */ +class ReadDishwasherAlarmEventList : public ReadAttribute { +public: + ReadDishwasherAlarmEventList() + : ReadAttribute("event-list") + { + } + + ~ReadDishwasherAlarmEventList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x0000FFFA) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeEventListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.EventList response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm EventList read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmEventList : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmEventList() + : SubscribeAttribute("event-list") + { + } + + ~SubscribeAttributeDishwasherAlarmEventList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x0000FFFA) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeEventListWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.EventList response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute AttributeList + */ +class ReadDishwasherAlarmAttributeList : public ReadAttribute { +public: + ReadDishwasherAlarmAttributeList() + : ReadAttribute("attribute-list") + { + } + + ~ReadDishwasherAlarmAttributeList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x0000FFFB) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeAttributeListWithCompletion:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.AttributeList response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm AttributeList read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmAttributeList : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmAttributeList() + : SubscribeAttribute("attribute-list") + { + } + + ~SubscribeAttributeDishwasherAlarmAttributeList() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x0000FFFB) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeAttributeListWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSArray * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.AttributeList response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute FeatureMap + */ +class ReadDishwasherAlarmFeatureMap : public ReadAttribute { +public: + ReadDishwasherAlarmFeatureMap() + : ReadAttribute("feature-map") + { + } + + ~ReadDishwasherAlarmFeatureMap() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x0000FFFC) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeFeatureMapWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.FeatureMap response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm FeatureMap read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmFeatureMap : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmFeatureMap() + : SubscribeAttribute("feature-map") + { + } + + ~SubscribeAttributeDishwasherAlarmFeatureMap() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x0000FFFC) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeFeatureMapWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.FeatureMap response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + +/* + * Attribute ClusterRevision + */ +class ReadDishwasherAlarmClusterRevision : public ReadAttribute { +public: + ReadDishwasherAlarmClusterRevision() + : ReadAttribute("cluster-revision") + { + } + + ~ReadDishwasherAlarmClusterRevision() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x0000FFFD) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeClusterRevisionWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.ClusterRevision response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm ClusterRevision read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmClusterRevision : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmClusterRevision() + : SubscribeAttribute("cluster-revision") + { + } + + ~SubscribeAttributeDishwasherAlarmClusterRevision() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x0000FFFD) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeClusterRevisionWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.ClusterRevision response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + /*----------------------------------------------------------------------------*\ | Cluster HepaFilterMonitoring | 0x0071 | |------------------------------------------------------------------------------| @@ -116773,6 +117517,43 @@ void registerClusterSmokeCoAlarm(Commands & commands) commands.Register(clusterName, clusterCommands); } +void registerClusterDishwasherAlarm(Commands & commands) +{ + using namespace chip::app::Clusters::DishwasherAlarm; + + const char * clusterName = "DishwasherAlarm"; + + commands_list clusterCommands = { + make_unique(Id), // + make_unique(), // + make_unique(Id), // + make_unique(), // + make_unique(Id), // + make_unique(), // + make_unique(Id), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(Id), // + make_unique(Id), // + }; + + commands.Register(clusterName, clusterCommands); +} void registerClusterHepaFilterMonitoring(Commands & commands) { using namespace chip::app::Clusters::HepaFilterMonitoring; @@ -119344,6 +120125,7 @@ void registerClusters(Commands & commands) registerClusterRefrigeratorAlarm(commands); registerClusterAirQuality(commands); registerClusterSmokeCoAlarm(commands); + registerClusterDishwasherAlarm(commands); registerClusterHepaFilterMonitoring(commands); registerClusterActivatedCarbonFilterMonitoring(commands); registerClusterCeramicFilterMonitoring(commands); diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h index 8166cd647a3d19..2943aa7ca28e54 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClientCallbacks.h @@ -450,6 +450,14 @@ typedef void (*SmokeCoAlarmEventListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); typedef void (*SmokeCoAlarmAttributeListListAttributeCallback)(void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmGeneratedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmAcceptedCommandListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmEventListListAttributeCallback)(void * context, + const chip::app::DataModel::DecodableList & data); +typedef void (*DishwasherAlarmAttributeListListAttributeCallback)( + void * context, const chip::app::DataModel::DecodableList & data); typedef void (*HepaFilterMonitoringGeneratedCommandListListAttributeCallback)( void * context, const chip::app::DataModel::DecodableList & data); typedef void (*HepaFilterMonitoringAcceptedCommandListListAttributeCallback)( diff --git a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h index 9dc22ecc288536..bd2aea1137bd81 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/CHIPClusters.h @@ -400,6 +400,15 @@ class DLL_EXPORT SmokeCoAlarmCluster : public ClusterBase ~SmokeCoAlarmCluster() {} }; +class DLL_EXPORT DishwasherAlarmCluster : public ClusterBase +{ +public: + DishwasherAlarmCluster(Messaging::ExchangeManager & exchangeManager, const SessionHandle & session, EndpointId endpoint) : + ClusterBase(exchangeManager, session, endpoint) + {} + ~DishwasherAlarmCluster() {} +}; + class DLL_EXPORT HepaFilterMonitoringCluster : public ClusterBase { public: 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 c71929f8951104..2d860037dc7b5e 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/endpoint_config.h @@ -59,7 +59,7 @@ #define GENERATED_FUNCTION_ARRAYS // This is an array of EmberAfCluster structures. -#define GENERATED_CLUSTER_COUNT 81 +#define GENERATED_CLUSTER_COUNT 82 // clang-format off #define GENERATED_CLUSTERS { \ { \ @@ -582,6 +582,19 @@ .eventList = nullptr, \ .eventCount = 0, \ },\ + { \ + /* Endpoint: 1, Cluster: Dishwasher Alarm (client) */ \ + .clusterId = 0x0000005D, \ + .attributes = ZAP_ATTRIBUTE_INDEX(0), \ + .attributeCount = 0, \ + .clusterSize = 0, \ + .mask = ZAP_CLUSTER_MASK(CLIENT), \ + .functions = NULL, \ + .acceptedCommandList = nullptr, \ + .generatedCommandList = nullptr, \ + .eventList = nullptr, \ + .eventCount = 0, \ + },\ { \ /* Endpoint: 1, Cluster: HEPA Filter Monitoring (client) */ \ .clusterId = 0x00000071, \ @@ -1124,7 +1137,7 @@ // This is an array of EmberAfEndpointType structures. #define GENERATED_ENDPOINT_TYPES \ { \ - { ZAP_CLUSTER_INDEX(0), 81, 0 }, \ + { ZAP_CLUSTER_INDEX(0), 82, 0 }, \ } // Largest attribute size is needed for various buffers 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 7a1fca8e0d30f3..5121e8c4e0410a 100644 --- a/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h +++ b/zzz_generated/darwin/controller-clusters/zap-generated/gen_config.h @@ -61,6 +61,7 @@ #define EMBER_AF_REFRIGERATOR_ALARM_CLIENT_ENDPOINT_COUNT (1) #define EMBER_AF_AIR_QUALITY_CLUSTER_CLIENT_ENDPOINT_COUNT (1) #define EMBER_AF_SMOKE_CO_ALARM_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_DISHWASHER_ALARM_CLIENT_ENDPOINT_COUNT (1) #define EMBER_AF_HEPA_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) #define EMBER_AF_ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) #define EMBER_AF_CERAMIC_FILTER_MONITORING_CLUSTER_CLIENT_ENDPOINT_COUNT (1) @@ -265,6 +266,10 @@ #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 Dishwasher Alarm cluster is included +#define ZCL_USING_DISHWASHER_ALARM_CLIENT +#define EMBER_AF_PLUGIN_DISHWASHER_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 From fbfc6342e76dd0d0185f6b2729a5d4f7a393f7af Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Tue, 23 May 2023 16:57:36 -0400 Subject: [PATCH 02/14] Apply suggestions from code review Co-authored-by: Boris Zbarsky --- src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml index a69c9deed73ccb..d1ed3f3ac05ccb 100644 --- a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml +++ b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml @@ -24,7 +24,7 @@ limitations under the License. - + From 84b2ad41a3f6bec8b6f80fc2b802bdc064df14f1 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Wed, 24 May 2023 08:53:08 -0400 Subject: [PATCH 03/14] Added feature map --- .../zcl/data-model/chip/dishwasher-alarm.xml | 12 +- .../data_model/controller-clusters.matter | 11 +- .../data_model/controller-clusters.zap | 8 +- .../devicecontroller/ClusterReadMapping.java | 126 ++++++++++++++++++ .../devicecontroller/ClusterWriteMapping.java | 18 +++ .../python/chip/clusters/Objects.py | 10 +- .../CHIP/zap-generated/MTRBaseClusters.h | 11 +- .../app-common/zap-generated/cluster-enums.h | 13 +- 8 files changed, 200 insertions(+), 9 deletions(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml index d1ed3f3ac05ccb..33c0e8d24cf6f8 100644 --- a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml +++ b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml @@ -17,6 +17,16 @@ limitations under the License. + + + + + + + + + + @@ -26,7 +36,7 @@ limitations under the License. - + Dishwasher Alarm Appliances diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index 55f9434c9bb148..2c1f92185066fd 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -2982,7 +2982,16 @@ client cluster DishwasherAlarm = 93 { kDoorError = 0x4; kTempTooLow = 0x8; kTempTooHigh = 0x10; - kWaterLevelError = 0x11; + kWaterLevelError = 0x20; + } + + bitmap Feature : BITMAP32 { + kInflowError = 0x1; + kDrainError = 0x2; + kDoorError = 0x4; + kTempTooLow = 0x8; + kTempTooHigh = 0x10; + kWaterLevelError = 0x20; } info event Notify = 0 { diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 7ddb695558c77a..c6eeb787c7e77c 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -11111,7 +11111,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11127,7 +11127,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11143,7 +11143,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11159,7 +11159,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 4699afda59400e..66c26f27cc3e69 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -8420,6 +8420,131 @@ private static Map readSmokeCoAlarmInteractionInfo() { return result; } + private static Map readDishwasherAlarmInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readDishwasherAlarmMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readMaskAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmMaskCommandParams); + result.put("readMaskAttribute", readDishwasherAlarmMaskAttributeInteractionInfo); + Map readDishwasherAlarmLatchCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmLatchAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readLatchAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmLatchCommandParams); + result.put("readLatchAttribute", readDishwasherAlarmLatchAttributeInteractionInfo); + Map readDishwasherAlarmStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readStateAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmStateCommandParams); + result.put("readStateAttribute", readDishwasherAlarmStateAttributeInteractionInfo); + Map readDishwasherAlarmGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.DishwasherAlarmCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDishwasherAlarmClusterGeneratedCommandListAttributeCallback(), + readDishwasherAlarmGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo); + Map readDishwasherAlarmAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.DishwasherAlarmCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDishwasherAlarmClusterAcceptedCommandListAttributeCallback(), + readDishwasherAlarmAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo); + Map readDishwasherAlarmEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readEventListAttribute( + (ChipClusters.DishwasherAlarmCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedDishwasherAlarmClusterEventListAttributeCallback(), + readDishwasherAlarmEventListCommandParams); + result.put("readEventListAttribute", readDishwasherAlarmEventListAttributeInteractionInfo); + Map readDishwasherAlarmAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DishwasherAlarmCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDishwasherAlarmClusterAttributeListAttributeCallback(), + readDishwasherAlarmAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readDishwasherAlarmAttributeListAttributeInteractionInfo); + Map readDishwasherAlarmFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readDishwasherAlarmFeatureMapAttributeInteractionInfo); + Map readDishwasherAlarmClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDishwasherAlarmClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readDishwasherAlarmClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readHepaFilterMonitoringInteractionInfo() { Map result = new LinkedHashMap<>(); Map readHepaFilterMonitoringConditionCommandParams = @@ -19834,6 +19959,7 @@ public Map> getReadAttributeMap() { put("refrigeratorAlarm", readRefrigeratorAlarmInteractionInfo()); put("airQuality", readAirQualityInteractionInfo()); put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo()); + put("dishwasherAlarm", readDishwasherAlarmInteractionInfo()); 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 649598fc021af8..a5b3f16b622fd4 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -679,6 +679,24 @@ public Map> getWriteAttributeMap() { "writeSensitivityLevelAttribute", writeSmokeCoAlarmSensitivityLevelAttributeInteractionInfo); writeAttributeMap.put("smokeCoAlarm", writeSmokeCoAlarmInteractionInfo); + Map writeDishwasherAlarmInteractionInfo = new LinkedHashMap<>(); + Map writeDishwasherAlarmMaskCommandParams = + new LinkedHashMap(); + CommandParameterInfo dishwasherAlarmmaskCommandParameterInfo = + new CommandParameterInfo("value", Long.class, Long.class); + writeDishwasherAlarmMaskCommandParams.put("value", dishwasherAlarmmaskCommandParameterInfo); + InteractionInfo writeDishwasherAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .writeMaskAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDishwasherAlarmMaskCommandParams); + writeDishwasherAlarmInteractionInfo.put( + "writeMaskAttribute", writeDishwasherAlarmMaskAttributeInteractionInfo); + writeAttributeMap.put("dishwasherAlarm", writeDishwasherAlarmInteractionInfo); Map writeHepaFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("hepaFilterMonitoring", writeHepaFilterMonitoringInteractionInfo); Map writeActivatedCarbonFilterMonitoringInteractionInfo = diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 2aa966d38b467d..a6163125fd9686 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -16392,7 +16392,15 @@ class AlarmMap(IntFlag): kDoorError = 0x4 kTempTooLow = 0x8 kTempTooHigh = 0x10 - kWaterLevelError = 0x11 + kWaterLevelError = 0x20 + + class Feature(IntFlag): + kInflowError = 0x1 + kDrainError = 0x2 + kDoorError = 0x4 + kTempTooLow = 0x8 + kTempTooHigh = 0x10 + kWaterLevelError = 0x20 class Commands: @dataclass diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index f349f0df1abb66..29744349ba8857 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -23551,7 +23551,16 @@ typedef NS_OPTIONS(uint32_t, MTRDishwasherAlarmAlarmMap) { MTRDishwasherAlarmAlarmMapDoorError MTR_NEWLY_AVAILABLE = 0x4, MTRDishwasherAlarmAlarmMapTempTooLow MTR_NEWLY_AVAILABLE = 0x8, MTRDishwasherAlarmAlarmMapTempTooHigh MTR_NEWLY_AVAILABLE = 0x10, - MTRDishwasherAlarmAlarmMapWaterLevelError MTR_NEWLY_AVAILABLE = 0x11, + MTRDishwasherAlarmAlarmMapWaterLevelError MTR_NEWLY_AVAILABLE = 0x20, +} MTR_NEWLY_AVAILABLE; + +typedef NS_OPTIONS(uint32_t, MTRDishwasherAlarmFeature) { + MTRDishwasherAlarmFeatureInflowError MTR_NEWLY_AVAILABLE = 0x1, + MTRDishwasherAlarmFeatureDrainError MTR_NEWLY_AVAILABLE = 0x2, + MTRDishwasherAlarmFeatureDoorError MTR_NEWLY_AVAILABLE = 0x4, + MTRDishwasherAlarmFeatureTempTooLow MTR_NEWLY_AVAILABLE = 0x8, + MTRDishwasherAlarmFeatureTempTooHigh MTR_NEWLY_AVAILABLE = 0x10, + MTRDishwasherAlarmFeatureWaterLevelError MTR_NEWLY_AVAILABLE = 0x20, } MTR_NEWLY_AVAILABLE; typedef NS_ENUM(uint8_t, MTRHEPAFilterMonitoringChangeIndication) { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index b135e682178c77..21c7e057098cf5 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -1659,7 +1659,18 @@ enum class AlarmMap : uint32_t kDoorError = 0x4, kTempTooLow = 0x8, kTempTooHigh = 0x10, - kWaterLevelError = 0x11, + kWaterLevelError = 0x20, +}; + +// Bitmap for Feature +enum class Feature : uint32_t +{ + kInflowError = 0x1, + kDrainError = 0x2, + kDoorError = 0x4, + kTempTooLow = 0x8, + kTempTooHigh = 0x10, + kWaterLevelError = 0x20, }; } // namespace DishwasherAlarm From 0af3c71ec2e7d01b90cee73a3e61627db41eae09 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Wed, 24 May 2023 11:47:27 -0400 Subject: [PATCH 04/14] Change after merge from upstream and regen-all --- .../devicecontroller/ClusterIDMapping.java | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index a8177c5fda8ca4..908bd1bfd381e8 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -172,6 +172,9 @@ public static BaseCluster getCluster(long clusterId) { if (clusterId == SmokeCoAlarm.ID) { return new SmokeCoAlarm(); } + if (clusterId == DishwasherAlarm.ID) { + return new DishwasherAlarm(); + } if (clusterId == HepaFilterMonitoring.ID) { return new HepaFilterMonitoring(); } @@ -7728,6 +7731,145 @@ public long getCommandID(String name) throws IllegalArgumentException { } } + public static class DishwasherAlarm implements BaseCluster { + public static final long ID = 93L; + + public long getID() { + return ID; + } + + public enum Attribute { + Mask(0L), + Latch(1L), + State(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Notify(0L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Reset(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ResetCommandField { + Alarms(0), + Mask(1), + ; + private final int id; + + ResetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ResetCommandField value(int id) throws NoSuchFieldError { + for (ResetCommandField field : ResetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class HepaFilterMonitoring implements BaseCluster { public static final long ID = 113L; From 73d44a2e93daae5ebf15f95cd72b78c92b60033f Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Wed, 24 May 2023 12:12:40 -0400 Subject: [PATCH 05/14] Adding files after manual step --- .../devicecontroller/ClusterIDMapping.java | 28243 ++++++------ .../devicecontroller/ClusterReadMapping.java | 35571 +++++++--------- .../devicecontroller/ClusterWriteMapping.java | 7753 ++-- 3 files changed, 32968 insertions(+), 38599 deletions(-) diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 908bd1bfd381e8..641d827ded0a63 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -17,15292 +17,13117 @@ package chip.devicecontroller; public class ClusterIDMapping { - public interface BaseCluster { - long getID(); - - String getAttributeName(long id) throws NoSuchFieldError; - - String getEventName(long id) throws NoSuchFieldError; - - String getCommandName(long id) throws NoSuchFieldError; - - long getAttributeID(String name) throws IllegalArgumentException; - - long getEventID(String name) throws IllegalArgumentException; - - long getCommandID(String name) throws IllegalArgumentException; - } - - public static BaseCluster getCluster(long clusterId) { - if (clusterId == Identify.ID) { - return new Identify(); - } - if (clusterId == Groups.ID) { - return new Groups(); - } - if (clusterId == Scenes.ID) { - return new Scenes(); - } - if (clusterId == OnOff.ID) { - return new OnOff(); - } - if (clusterId == OnOffSwitchConfiguration.ID) { - return new OnOffSwitchConfiguration(); - } - if (clusterId == LevelControl.ID) { - return new LevelControl(); - } - if (clusterId == BinaryInputBasic.ID) { - return new BinaryInputBasic(); - } - if (clusterId == PulseWidthModulation.ID) { - return new PulseWidthModulation(); - } - if (clusterId == Descriptor.ID) { - return new Descriptor(); - } - if (clusterId == Binding.ID) { - return new Binding(); - } - if (clusterId == AccessControl.ID) { - return new AccessControl(); - } - if (clusterId == Actions.ID) { - return new Actions(); - } - if (clusterId == BasicInformation.ID) { - return new BasicInformation(); - } - if (clusterId == OtaSoftwareUpdateProvider.ID) { - return new OtaSoftwareUpdateProvider(); - } - if (clusterId == OtaSoftwareUpdateRequestor.ID) { - return new OtaSoftwareUpdateRequestor(); - } - if (clusterId == LocalizationConfiguration.ID) { - return new LocalizationConfiguration(); - } - if (clusterId == TimeFormatLocalization.ID) { - return new TimeFormatLocalization(); - } - if (clusterId == UnitLocalization.ID) { - return new UnitLocalization(); - } - if (clusterId == PowerSourceConfiguration.ID) { - return new PowerSourceConfiguration(); - } - if (clusterId == PowerSource.ID) { - return new PowerSource(); - } - if (clusterId == GeneralCommissioning.ID) { - return new GeneralCommissioning(); - } - if (clusterId == NetworkCommissioning.ID) { - return new NetworkCommissioning(); - } - if (clusterId == DiagnosticLogs.ID) { - return new DiagnosticLogs(); - } - if (clusterId == GeneralDiagnostics.ID) { - return new GeneralDiagnostics(); - } - if (clusterId == SoftwareDiagnostics.ID) { - return new SoftwareDiagnostics(); - } - if (clusterId == ThreadNetworkDiagnostics.ID) { - return new ThreadNetworkDiagnostics(); - } - if (clusterId == WiFiNetworkDiagnostics.ID) { - return new WiFiNetworkDiagnostics(); - } - if (clusterId == EthernetNetworkDiagnostics.ID) { - return new EthernetNetworkDiagnostics(); - } - if (clusterId == TimeSynchronization.ID) { - return new TimeSynchronization(); - } - if (clusterId == BridgedDeviceBasicInformation.ID) { - return new BridgedDeviceBasicInformation(); - } - if (clusterId == Switch.ID) { - return new Switch(); - } - if (clusterId == AdministratorCommissioning.ID) { - return new AdministratorCommissioning(); - } - if (clusterId == OperationalCredentials.ID) { - return new OperationalCredentials(); - } - if (clusterId == GroupKeyManagement.ID) { - return new GroupKeyManagement(); - } - if (clusterId == FixedLabel.ID) { - return new FixedLabel(); - } - if (clusterId == UserLabel.ID) { - return new UserLabel(); - } - if (clusterId == ProxyConfiguration.ID) { - return new ProxyConfiguration(); - } - if (clusterId == ProxyDiscovery.ID) { - return new ProxyDiscovery(); - } - if (clusterId == ProxyValid.ID) { - return new ProxyValid(); - } - if (clusterId == BooleanState.ID) { - return new BooleanState(); - } - if (clusterId == IcdManagement.ID) { - return new IcdManagement(); - } - if (clusterId == ModeSelect.ID) { - return new ModeSelect(); - } - if (clusterId == TemperatureControl.ID) { - return new TemperatureControl(); - } - if (clusterId == RefrigeratorAlarm.ID) { - return new RefrigeratorAlarm(); - } - if (clusterId == AirQuality.ID) { - return new AirQuality(); - } - if (clusterId == SmokeCoAlarm.ID) { - return new SmokeCoAlarm(); - } - if (clusterId == DishwasherAlarm.ID) { - return new DishwasherAlarm(); - } - if (clusterId == HepaFilterMonitoring.ID) { - return new HepaFilterMonitoring(); - } - if (clusterId == ActivatedCarbonFilterMonitoring.ID) { - return new ActivatedCarbonFilterMonitoring(); - } - if (clusterId == CeramicFilterMonitoring.ID) { - return new CeramicFilterMonitoring(); - } - if (clusterId == ElectrostaticFilterMonitoring.ID) { - return new ElectrostaticFilterMonitoring(); - } - if (clusterId == UvFilterMonitoring.ID) { - return new UvFilterMonitoring(); - } - if (clusterId == IonizingFilterMonitoring.ID) { - return new IonizingFilterMonitoring(); - } - if (clusterId == ZeoliteFilterMonitoring.ID) { - return new ZeoliteFilterMonitoring(); - } - if (clusterId == OzoneFilterMonitoring.ID) { - return new OzoneFilterMonitoring(); - } - if (clusterId == WaterTankMonitoring.ID) { - return new WaterTankMonitoring(); - } - if (clusterId == FuelTankMonitoring.ID) { - return new FuelTankMonitoring(); - } - if (clusterId == InkCartridgeMonitoring.ID) { - return new InkCartridgeMonitoring(); + public interface BaseCluster { + long getID(); + String getAttributeName(long id) throws NoSuchFieldError; + String getEventName(long id) throws NoSuchFieldError; + String getCommandName(long id) throws NoSuchFieldError; + long getAttributeID(String name) throws IllegalArgumentException; + long getEventID(String name) throws IllegalArgumentException; + long getCommandID(String name) throws IllegalArgumentException; } - if (clusterId == TonerCartridgeMonitoring.ID) { - return new TonerCartridgeMonitoring(); - } - if (clusterId == DoorLock.ID) { - return new DoorLock(); - } - if (clusterId == WindowCovering.ID) { - return new WindowCovering(); - } - if (clusterId == BarrierControl.ID) { - return new BarrierControl(); - } - if (clusterId == PumpConfigurationAndControl.ID) { - return new PumpConfigurationAndControl(); - } - if (clusterId == Thermostat.ID) { - return new Thermostat(); - } - if (clusterId == FanControl.ID) { - return new FanControl(); - } - if (clusterId == ThermostatUserInterfaceConfiguration.ID) { - return new ThermostatUserInterfaceConfiguration(); - } - if (clusterId == ColorControl.ID) { - return new ColorControl(); - } - if (clusterId == BallastConfiguration.ID) { - return new BallastConfiguration(); - } - if (clusterId == IlluminanceMeasurement.ID) { - return new IlluminanceMeasurement(); - } - if (clusterId == TemperatureMeasurement.ID) { - return new TemperatureMeasurement(); - } - if (clusterId == PressureMeasurement.ID) { - return new PressureMeasurement(); - } - if (clusterId == FlowMeasurement.ID) { - return new FlowMeasurement(); - } - if (clusterId == RelativeHumidityMeasurement.ID) { - return new RelativeHumidityMeasurement(); - } - if (clusterId == OccupancySensing.ID) { - return new OccupancySensing(); - } - if (clusterId == WakeOnLan.ID) { - return new WakeOnLan(); - } - if (clusterId == Channel.ID) { - return new Channel(); - } - if (clusterId == TargetNavigator.ID) { - return new TargetNavigator(); - } - if (clusterId == MediaPlayback.ID) { - return new MediaPlayback(); - } - if (clusterId == MediaInput.ID) { - return new MediaInput(); - } - if (clusterId == LowPower.ID) { - return new LowPower(); - } - if (clusterId == KeypadInput.ID) { - return new KeypadInput(); - } - if (clusterId == ContentLauncher.ID) { - return new ContentLauncher(); - } - if (clusterId == AudioOutput.ID) { - return new AudioOutput(); - } - if (clusterId == ApplicationLauncher.ID) { - return new ApplicationLauncher(); - } - if (clusterId == ApplicationBasic.ID) { - return new ApplicationBasic(); - } - if (clusterId == AccountLogin.ID) { - return new AccountLogin(); - } - if (clusterId == ElectricalMeasurement.ID) { - return new ElectricalMeasurement(); - } - if (clusterId == UnitTesting.ID) { - return new UnitTesting(); - } - if (clusterId == FaultInjection.ID) { - return new FaultInjection(); - } - return null; - } - - public static class Identify implements BaseCluster { - public static final long ID = 3L; - public long getID() { - return ID; - } - - public enum Attribute { - IdentifyTime(0L), - IdentifyType(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + public static BaseCluster getCluster(long clusterId) { + if (clusterId == Identify.ID) { + return new Identify(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Identify(0L), - TriggerEffect(64L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == Groups.ID) { + return new Groups(); } - throw new NoSuchFieldError(); - } - } - - public enum IdentifyCommandField { - IdentifyTime(0), - ; - private final int id; - - IdentifyCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static IdentifyCommandField value(int id) throws NoSuchFieldError { - for (IdentifyCommandField field : IdentifyCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == Scenes.ID) { + return new Scenes(); } - throw new NoSuchFieldError(); - } - } - - public enum TriggerEffectCommandField { - EffectIdentifier(0), - EffectVariant(1), - ; - private final int id; - - TriggerEffectCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TriggerEffectCommandField value(int id) throws NoSuchFieldError { - for (TriggerEffectCommandField field : TriggerEffectCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == OnOff.ID) { + return new OnOff(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Groups implements BaseCluster { - public static final long ID = 4L; - - public long getID() { - return ID; - } - - public enum Attribute { - NameSupport(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == OnOffSwitchConfiguration.ID) { + return new OnOffSwitchConfiguration(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AddGroup(0L), - ViewGroup(1L), - GetGroupMembership(2L), - RemoveGroup(3L), - RemoveAllGroups(4L), - AddGroupIfIdentifying(5L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AddGroupCommandField { - GroupID(0), - GroupName(1), - ; - private final int id; - - AddGroupCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddGroupCommandField value(int id) throws NoSuchFieldError { - for (AddGroupCommandField field : AddGroupCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == LevelControl.ID) { + return new LevelControl(); } - throw new NoSuchFieldError(); - } - } - - public enum ViewGroupCommandField { - GroupID(0), - ; - private final int id; - - ViewGroupCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ViewGroupCommandField value(int id) throws NoSuchFieldError { - for (ViewGroupCommandField field : ViewGroupCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == BinaryInputBasic.ID) { + return new BinaryInputBasic(); } - throw new NoSuchFieldError(); - } - } - - public enum GetGroupMembershipCommandField { - GroupList(0), - ; - private final int id; - - GetGroupMembershipCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetGroupMembershipCommandField value(int id) throws NoSuchFieldError { - for (GetGroupMembershipCommandField field : GetGroupMembershipCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == PulseWidthModulation.ID) { + return new PulseWidthModulation(); } - throw new NoSuchFieldError(); - } - } - - public enum RemoveGroupCommandField { - GroupID(0), - ; - private final int id; - - RemoveGroupCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RemoveGroupCommandField value(int id) throws NoSuchFieldError { - for (RemoveGroupCommandField field : RemoveGroupCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == Descriptor.ID) { + return new Descriptor(); } - throw new NoSuchFieldError(); - } - } - - public enum AddGroupIfIdentifyingCommandField { - GroupID(0), - GroupName(1), - ; - private final int id; - - AddGroupIfIdentifyingCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddGroupIfIdentifyingCommandField value(int id) throws NoSuchFieldError { - for (AddGroupIfIdentifyingCommandField field : AddGroupIfIdentifyingCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == Binding.ID) { + return new Binding(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Scenes implements BaseCluster { - public static final long ID = 5L; - - public long getID() { - return ID; - } - - public enum Attribute { - SceneCount(0L), - CurrentScene(1L), - CurrentGroup(2L), - SceneValid(3L), - NameSupport(4L), - LastConfiguredBy(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == AccessControl.ID) { + return new AccessControl(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AddScene(0L), - ViewScene(1L), - RemoveScene(2L), - RemoveAllScenes(3L), - StoreScene(4L), - RecallScene(5L), - GetSceneMembership(6L), - EnhancedAddScene(64L), - EnhancedViewScene(65L), - CopyScene(66L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AddSceneCommandField { - GroupID(0), - SceneID(1), - TransitionTime(2), - SceneName(3), - ExtensionFieldSets(4), - ; - private final int id; - - AddSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddSceneCommandField value(int id) throws NoSuchFieldError { - for (AddSceneCommandField field : AddSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ViewSceneCommandField { - GroupID(0), - SceneID(1), - ; - private final int id; - - ViewSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ViewSceneCommandField value(int id) throws NoSuchFieldError { - for (ViewSceneCommandField field : ViewSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == Actions.ID) { + return new Actions(); } - throw new NoSuchFieldError(); - } - } - - public enum RemoveSceneCommandField { - GroupID(0), - SceneID(1), - ; - private final int id; - - RemoveSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RemoveSceneCommandField value(int id) throws NoSuchFieldError { - for (RemoveSceneCommandField field : RemoveSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == BasicInformation.ID) { + return new BasicInformation(); } - throw new NoSuchFieldError(); - } - } - - public enum RemoveAllScenesCommandField { - GroupID(0), - ; - private final int id; - - RemoveAllScenesCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RemoveAllScenesCommandField value(int id) throws NoSuchFieldError { - for (RemoveAllScenesCommandField field : RemoveAllScenesCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == OtaSoftwareUpdateProvider.ID) { + return new OtaSoftwareUpdateProvider(); } - throw new NoSuchFieldError(); - } - } - - public enum StoreSceneCommandField { - GroupID(0), - SceneID(1), - ; - private final int id; - - StoreSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StoreSceneCommandField value(int id) throws NoSuchFieldError { - for (StoreSceneCommandField field : StoreSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == OtaSoftwareUpdateRequestor.ID) { + return new OtaSoftwareUpdateRequestor(); } - throw new NoSuchFieldError(); - } - } - - public enum RecallSceneCommandField { - GroupID(0), - SceneID(1), - TransitionTime(2), - ; - private final int id; - - RecallSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RecallSceneCommandField value(int id) throws NoSuchFieldError { - for (RecallSceneCommandField field : RecallSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetSceneMembershipCommandField { - GroupID(0), - ; - private final int id; - - GetSceneMembershipCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetSceneMembershipCommandField value(int id) throws NoSuchFieldError { - for (GetSceneMembershipCommandField field : GetSceneMembershipCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == LocalizationConfiguration.ID) { + return new LocalizationConfiguration(); } - throw new NoSuchFieldError(); - } - } - - public enum EnhancedAddSceneCommandField { - GroupID(0), - SceneID(1), - TransitionTime(2), - SceneName(3), - ExtensionFieldSets(4), - ; - private final int id; - - EnhancedAddSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnhancedAddSceneCommandField value(int id) throws NoSuchFieldError { - for (EnhancedAddSceneCommandField field : EnhancedAddSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnhancedViewSceneCommandField { - GroupID(0), - SceneID(1), - ; - private final int id; - - EnhancedViewSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnhancedViewSceneCommandField value(int id) throws NoSuchFieldError { - for (EnhancedViewSceneCommandField field : EnhancedViewSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == TimeFormatLocalization.ID) { + return new TimeFormatLocalization(); } - throw new NoSuchFieldError(); - } - } - - public enum CopySceneCommandField { - Mode(0), - GroupIdentifierFrom(1), - SceneIdentifierFrom(2), - GroupIdentifierTo(3), - SceneIdentifierTo(4), - ; - private final int id; - - CopySceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static CopySceneCommandField value(int id) throws NoSuchFieldError { - for (CopySceneCommandField field : CopySceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OnOff implements BaseCluster { - public static final long ID = 6L; - - public long getID() { - return ID; - } - - public enum Attribute { - OnOff(0L), - GlobalSceneControl(16384L), - OnTime(16385L), - OffWaitTime(16386L), - StartUpOnOff(16387L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == UnitLocalization.ID) { + return new UnitLocalization(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Off(0L), - On(1L), - Toggle(2L), - OffWithEffect(64L), - OnWithRecallGlobalScene(65L), - OnWithTimedOff(66L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum OffWithEffectCommandField { - EffectIdentifier(0), - EffectVariant(1), - ; - private final int id; - - OffWithEffectCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static OffWithEffectCommandField value(int id) throws NoSuchFieldError { - for (OffWithEffectCommandField field : OffWithEffectCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum OnWithTimedOffCommandField { - OnOffControl(0), - OnTime(1), - OffWaitTime(2), - ; - private final int id; - - OnWithTimedOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static OnWithTimedOffCommandField value(int id) throws NoSuchFieldError { - for (OnWithTimedOffCommandField field : OnWithTimedOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OnOffSwitchConfiguration implements BaseCluster { - public static final long ID = 7L; - - public long getID() { - return ID; - } - - public enum Attribute { - SwitchType(0L), - SwitchActions(16L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class LevelControl implements BaseCluster { - public static final long ID = 8L; - - public long getID() { - return ID; - } - - public enum Attribute { - CurrentLevel(0L), - RemainingTime(1L), - MinLevel(2L), - MaxLevel(3L), - CurrentFrequency(4L), - MinFrequency(5L), - MaxFrequency(6L), - Options(15L), - OnOffTransitionTime(16L), - OnLevel(17L), - OnTransitionTime(18L), - OffTransitionTime(19L), - DefaultMoveRate(20L), - StartUpCurrentLevel(16384L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - MoveToLevel(0L), - Move(1L), - Step(2L), - Stop(3L), - MoveToLevelWithOnOff(4L), - MoveWithOnOff(5L), - StepWithOnOff(6L), - StopWithOnOff(7L), - MoveToClosestFrequency(8L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToLevelCommandField { - Level(0), - TransitionTime(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveToLevelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToLevelCommandField value(int id) throws NoSuchFieldError { - for (MoveToLevelCommandField field : MoveToLevelCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveCommandField { - MoveMode(0), - Rate(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveCommandField value(int id) throws NoSuchFieldError { - for (MoveCommandField field : MoveCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StepCommandField { - StepMode(0), - StepSize(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - StepCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StepCommandField value(int id) throws NoSuchFieldError { - for (StepCommandField field : StepCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StopCommandField { - OptionsMask(0), - OptionsOverride(1), - ; - private final int id; - - StopCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StopCommandField value(int id) throws NoSuchFieldError { - for (StopCommandField field : StopCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToLevelWithOnOffCommandField { - Level(0), - TransitionTime(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveToLevelWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToLevelWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (MoveToLevelWithOnOffCommandField field : MoveToLevelWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveWithOnOffCommandField { - MoveMode(0), - Rate(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (MoveWithOnOffCommandField field : MoveWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StepWithOnOffCommandField { - StepMode(0), - StepSize(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - StepWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StepWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (StepWithOnOffCommandField field : StepWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StopWithOnOffCommandField { - OptionsMask(0), - OptionsOverride(1), - ; - private final int id; - - StopWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StopWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (StopWithOnOffCommandField field : StopWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToClosestFrequencyCommandField { - Frequency(0), - ; - private final int id; - - MoveToClosestFrequencyCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToClosestFrequencyCommandField value(int id) throws NoSuchFieldError { - for (MoveToClosestFrequencyCommandField field : - MoveToClosestFrequencyCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class BinaryInputBasic implements BaseCluster { - public static final long ID = 15L; - - public long getID() { - return ID; - } - - public enum Attribute { - ActiveText(4L), - Description(28L), - InactiveText(46L), - OutOfService(81L), - Polarity(84L), - PresentValue(85L), - Reliability(103L), - StatusFlags(111L), - ApplicationType(256L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class PulseWidthModulation implements BaseCluster { - public static final long ID = 28L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Descriptor implements BaseCluster { - public static final long ID = 29L; - - public long getID() { - return ID; - } - - public enum Attribute { - DeviceTypeList(0L), - ServerList(1L), - ClientList(2L), - PartsList(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Binding implements BaseCluster { - public static final long ID = 30L; - - public long getID() { - return ID; - } - - public enum Attribute { - Binding(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class AccessControl implements BaseCluster { - public static final long ID = 31L; - - public long getID() { - return ID; - } - - public enum Attribute { - Acl(0L), - Extension(1L), - SubjectsPerAccessControlEntry(2L), - TargetsPerAccessControlEntry(3L), - AccessControlEntriesPerFabric(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - AccessControlEntryChanged(0L), - AccessControlExtensionChanged(1L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Actions implements BaseCluster { - public static final long ID = 37L; - - public long getID() { - return ID; - } - - public enum Attribute { - ActionList(0L), - EndpointLists(1L), - SetupURL(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StateChanged(0L), - ActionFailed(1L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - InstantAction(0L), - InstantActionWithTransition(1L), - StartAction(2L), - StartActionWithDuration(3L), - StopAction(4L), - PauseAction(5L), - PauseActionWithDuration(6L), - ResumeAction(7L), - EnableAction(8L), - EnableActionWithDuration(9L), - DisableAction(10L), - DisableActionWithDuration(11L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum InstantActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - InstantActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static InstantActionCommandField value(int id) throws NoSuchFieldError { - for (InstantActionCommandField field : InstantActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum InstantActionWithTransitionCommandField { - ActionID(0), - InvokeID(1), - TransitionTime(2), - ; - private final int id; - - InstantActionWithTransitionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static InstantActionWithTransitionCommandField value(int id) throws NoSuchFieldError { - for (InstantActionWithTransitionCommandField field : - InstantActionWithTransitionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StartActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - StartActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StartActionCommandField value(int id) throws NoSuchFieldError { - for (StartActionCommandField field : StartActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StartActionWithDurationCommandField { - ActionID(0), - InvokeID(1), - Duration(2), - ; - private final int id; - - StartActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StartActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (StartActionWithDurationCommandField field : - StartActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StopActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - StopActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StopActionCommandField value(int id) throws NoSuchFieldError { - for (StopActionCommandField field : StopActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum PauseActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - PauseActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static PauseActionCommandField value(int id) throws NoSuchFieldError { - for (PauseActionCommandField field : PauseActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum PauseActionWithDurationCommandField { - ActionID(0), - InvokeID(1), - Duration(2), - ; - private final int id; - - PauseActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static PauseActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (PauseActionWithDurationCommandField field : - PauseActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ResumeActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - ResumeActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ResumeActionCommandField value(int id) throws NoSuchFieldError { - for (ResumeActionCommandField field : ResumeActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnableActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - EnableActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnableActionCommandField value(int id) throws NoSuchFieldError { - for (EnableActionCommandField field : EnableActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnableActionWithDurationCommandField { - ActionID(0), - InvokeID(1), - Duration(2), - ; - private final int id; - - EnableActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnableActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (EnableActionWithDurationCommandField field : - EnableActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum DisableActionCommandField { - ActionID(0), - InvokeID(1), - ; - private final int id; - - DisableActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static DisableActionCommandField value(int id) throws NoSuchFieldError { - for (DisableActionCommandField field : DisableActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum DisableActionWithDurationCommandField { - ActionID(0), - InvokeID(1), - Duration(2), - ; - private final int id; - - DisableActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static DisableActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (DisableActionWithDurationCommandField field : - DisableActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class BasicInformation implements BaseCluster { - public static final long ID = 40L; - - public long getID() { - return ID; - } - - public enum Attribute { - DataModelRevision(0L), - VendorName(1L), - VendorID(2L), - ProductName(3L), - ProductID(4L), - NodeLabel(5L), - Location(6L), - HardwareVersion(7L), - HardwareVersionString(8L), - SoftwareVersion(9L), - SoftwareVersionString(10L), - ManufacturingDate(11L), - PartNumber(12L), - ProductURL(13L), - ProductLabel(14L), - SerialNumber(15L), - LocalConfigDisabled(16L), - Reachable(17L), - UniqueID(18L), - CapabilityMinima(19L), - ProductAppearance(20L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StartUp(0L), - ShutDown(1L), - Leave(2L), - ReachableChanged(3L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - MfgSpecificPing(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OtaSoftwareUpdateProvider implements BaseCluster { - public static final long ID = 41L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - QueryImage(0L), - ApplyUpdateRequest(2L), - NotifyUpdateApplied(4L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum QueryImageCommandField { - VendorID(0), - ProductID(1), - SoftwareVersion(2), - ProtocolsSupported(3), - HardwareVersion(4), - Location(5), - RequestorCanConsent(6), - MetadataForProvider(7), - ; - private final int id; - - QueryImageCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static QueryImageCommandField value(int id) throws NoSuchFieldError { - for (QueryImageCommandField field : QueryImageCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ApplyUpdateRequestCommandField { - UpdateToken(0), - NewVersion(1), - ; - private final int id; - - ApplyUpdateRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ApplyUpdateRequestCommandField value(int id) throws NoSuchFieldError { - for (ApplyUpdateRequestCommandField field : ApplyUpdateRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum NotifyUpdateAppliedCommandField { - UpdateToken(0), - SoftwareVersion(1), - ; - private final int id; - - NotifyUpdateAppliedCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static NotifyUpdateAppliedCommandField value(int id) throws NoSuchFieldError { - for (NotifyUpdateAppliedCommandField field : NotifyUpdateAppliedCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OtaSoftwareUpdateRequestor implements BaseCluster { - public static final long ID = 42L; - - public long getID() { - return ID; - } - - public enum Attribute { - DefaultOTAProviders(0L), - UpdatePossible(1L), - UpdateState(2L), - UpdateStateProgress(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StateTransition(0L), - VersionApplied(1L), - DownloadError(2L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AnnounceOTAProvider(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AnnounceOTAProviderCommandField { - ProviderNodeID(0), - VendorID(1), - AnnouncementReason(2), - MetadataForNode(3), - Endpoint(4), - ; - private final int id; - - AnnounceOTAProviderCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AnnounceOTAProviderCommandField value(int id) throws NoSuchFieldError { - for (AnnounceOTAProviderCommandField field : AnnounceOTAProviderCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class LocalizationConfiguration implements BaseCluster { - public static final long ID = 43L; - - public long getID() { - return ID; - } - - public enum Attribute { - ActiveLocale(0L), - SupportedLocales(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class TimeFormatLocalization implements BaseCluster { - public static final long ID = 44L; - - public long getID() { - return ID; - } - - public enum Attribute { - HourFormat(0L), - ActiveCalendarType(1L), - SupportedCalendarTypes(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class UnitLocalization implements BaseCluster { - public static final long ID = 45L; - - public long getID() { - return ID; - } - - public enum Attribute { - TemperatureUnit(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class PowerSourceConfiguration implements BaseCluster { - public static final long ID = 46L; - - public long getID() { - return ID; - } - - public enum Attribute { - Sources(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class PowerSource implements BaseCluster { - public static final long ID = 47L; - - public long getID() { - return ID; - } - - public enum Attribute { - Status(0L), - Order(1L), - Description(2L), - WiredAssessedInputVoltage(3L), - WiredAssessedInputFrequency(4L), - WiredCurrentType(5L), - WiredAssessedCurrent(6L), - WiredNominalVoltage(7L), - WiredMaximumCurrent(8L), - WiredPresent(9L), - ActiveWiredFaults(10L), - BatVoltage(11L), - BatPercentRemaining(12L), - BatTimeRemaining(13L), - BatChargeLevel(14L), - BatReplacementNeeded(15L), - BatReplaceability(16L), - BatPresent(17L), - ActiveBatFaults(18L), - BatReplacementDescription(19L), - BatCommonDesignation(20L), - BatANSIDesignation(21L), - BatIECDesignation(22L), - BatApprovedChemistry(23L), - BatCapacity(24L), - BatQuantity(25L), - BatChargeState(26L), - BatTimeToFullCharge(27L), - BatFunctionalWhileCharging(28L), - BatChargingCurrent(29L), - ActiveBatChargeFaults(30L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - WiredFaultChange(0L), - BatFaultChange(1L), - BatChargeFaultChange(2L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class GeneralCommissioning implements BaseCluster { - public static final long ID = 48L; - - public long getID() { - return ID; - } - - public enum Attribute { - Breadcrumb(0L), - BasicCommissioningInfo(1L), - RegulatoryConfig(2L), - LocationCapability(3L), - SupportsConcurrentConnection(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ArmFailSafe(0L), - SetRegulatoryConfig(2L), - CommissioningComplete(4L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ArmFailSafeCommandField { - ExpiryLengthSeconds(0), - Breadcrumb(1), - ; - private final int id; - - ArmFailSafeCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ArmFailSafeCommandField value(int id) throws NoSuchFieldError { - for (ArmFailSafeCommandField field : ArmFailSafeCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetRegulatoryConfigCommandField { - NewRegulatoryConfig(0), - CountryCode(1), - Breadcrumb(2), - ; - private final int id; - - SetRegulatoryConfigCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetRegulatoryConfigCommandField value(int id) throws NoSuchFieldError { - for (SetRegulatoryConfigCommandField field : SetRegulatoryConfigCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class NetworkCommissioning implements BaseCluster { - public static final long ID = 49L; - - public long getID() { - return ID; - } - - public enum Attribute { - MaxNetworks(0L), - Networks(1L), - ScanMaxTimeSeconds(2L), - ConnectMaxTimeSeconds(3L), - InterfaceEnabled(4L), - LastNetworkingStatus(5L), - LastNetworkID(6L), - LastConnectErrorValue(7L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ScanNetworks(0L), - AddOrUpdateWiFiNetwork(2L), - AddOrUpdateThreadNetwork(3L), - RemoveNetwork(4L), - ConnectNetwork(6L), - ReorderNetwork(8L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ScanNetworksCommandField { - Ssid(0), - Breadcrumb(1), - ; - private final int id; - - ScanNetworksCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ScanNetworksCommandField value(int id) throws NoSuchFieldError { - for (ScanNetworksCommandField field : ScanNetworksCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AddOrUpdateWiFiNetworkCommandField { - Ssid(0), - Credentials(1), - Breadcrumb(2), - ; - private final int id; - - AddOrUpdateWiFiNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddOrUpdateWiFiNetworkCommandField value(int id) throws NoSuchFieldError { - for (AddOrUpdateWiFiNetworkCommandField field : - AddOrUpdateWiFiNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AddOrUpdateThreadNetworkCommandField { - OperationalDataset(0), - Breadcrumb(1), - ; - private final int id; - - AddOrUpdateThreadNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddOrUpdateThreadNetworkCommandField value(int id) throws NoSuchFieldError { - for (AddOrUpdateThreadNetworkCommandField field : - AddOrUpdateThreadNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum RemoveNetworkCommandField { - NetworkID(0), - Breadcrumb(1), - ; - private final int id; - - RemoveNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RemoveNetworkCommandField value(int id) throws NoSuchFieldError { - for (RemoveNetworkCommandField field : RemoveNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ConnectNetworkCommandField { - NetworkID(0), - Breadcrumb(1), - ; - private final int id; - - ConnectNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ConnectNetworkCommandField value(int id) throws NoSuchFieldError { - for (ConnectNetworkCommandField field : ConnectNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ReorderNetworkCommandField { - NetworkID(0), - NetworkIndex(1), - Breadcrumb(2), - ; - private final int id; - - ReorderNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ReorderNetworkCommandField value(int id) throws NoSuchFieldError { - for (ReorderNetworkCommandField field : ReorderNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class DiagnosticLogs implements BaseCluster { - public static final long ID = 50L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - RetrieveLogsRequest(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum RetrieveLogsRequestCommandField { - Intent(0), - RequestedProtocol(1), - TransferFileDesignator(2), - ; - private final int id; - - RetrieveLogsRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RetrieveLogsRequestCommandField value(int id) throws NoSuchFieldError { - for (RetrieveLogsRequestCommandField field : RetrieveLogsRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class GeneralDiagnostics implements BaseCluster { - public static final long ID = 51L; - - public long getID() { - return ID; - } - - public enum Attribute { - NetworkInterfaces(0L), - RebootCount(1L), - UpTime(2L), - TotalOperationalHours(3L), - BootReason(4L), - ActiveHardwareFaults(5L), - ActiveRadioFaults(6L), - ActiveNetworkFaults(7L), - TestEventTriggersEnabled(8L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - HardwareFaultChange(0L), - RadioFaultChange(1L), - NetworkFaultChange(2L), - BootReason(3L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - TestEventTrigger(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestEventTriggerCommandField { - EnableKey(0), - EventTrigger(1), - ; - private final int id; - - TestEventTriggerCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestEventTriggerCommandField value(int id) throws NoSuchFieldError { - for (TestEventTriggerCommandField field : TestEventTriggerCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class SoftwareDiagnostics implements BaseCluster { - public static final long ID = 52L; - - public long getID() { - return ID; - } - - public enum Attribute { - ThreadMetrics(0L), - CurrentHeapFree(1L), - CurrentHeapUsed(2L), - CurrentHeapHighWatermark(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SoftwareFault(0L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetWatermarks(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ThreadNetworkDiagnostics implements BaseCluster { - public static final long ID = 53L; - - public long getID() { - return ID; - } - - public enum Attribute { - Channel(0L), - RoutingRole(1L), - NetworkName(2L), - PanId(3L), - ExtendedPanId(4L), - MeshLocalPrefix(5L), - OverrunCount(6L), - NeighborTable(7L), - RouteTable(8L), - PartitionId(9L), - Weighting(10L), - DataVersion(11L), - StableDataVersion(12L), - LeaderRouterId(13L), - DetachedRoleCount(14L), - ChildRoleCount(15L), - RouterRoleCount(16L), - LeaderRoleCount(17L), - AttachAttemptCount(18L), - PartitionIdChangeCount(19L), - BetterPartitionAttachAttemptCount(20L), - ParentChangeCount(21L), - TxTotalCount(22L), - TxUnicastCount(23L), - TxBroadcastCount(24L), - TxAckRequestedCount(25L), - TxAckedCount(26L), - TxNoAckRequestedCount(27L), - TxDataCount(28L), - TxDataPollCount(29L), - TxBeaconCount(30L), - TxBeaconRequestCount(31L), - TxOtherCount(32L), - TxRetryCount(33L), - TxDirectMaxRetryExpiryCount(34L), - TxIndirectMaxRetryExpiryCount(35L), - TxErrCcaCount(36L), - TxErrAbortCount(37L), - TxErrBusyChannelCount(38L), - RxTotalCount(39L), - RxUnicastCount(40L), - RxBroadcastCount(41L), - RxDataCount(42L), - RxDataPollCount(43L), - RxBeaconCount(44L), - RxBeaconRequestCount(45L), - RxOtherCount(46L), - RxAddressFilteredCount(47L), - RxDestAddrFilteredCount(48L), - RxDuplicatedCount(49L), - RxErrNoFrameCount(50L), - RxErrUnknownNeighborCount(51L), - RxErrInvalidSrcAddrCount(52L), - RxErrSecCount(53L), - RxErrFcsCount(54L), - RxErrOtherCount(55L), - ActiveTimestamp(56L), - PendingTimestamp(57L), - Delay(58L), - SecurityPolicy(59L), - ChannelPage0Mask(60L), - OperationalDatasetComponents(61L), - ActiveNetworkFaultsList(62L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ConnectionStatus(0L), - NetworkFaultChange(1L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCounts(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class WiFiNetworkDiagnostics implements BaseCluster { - public static final long ID = 54L; - - public long getID() { - return ID; - } - - public enum Attribute { - Bssid(0L), - SecurityType(1L), - WiFiVersion(2L), - ChannelNumber(3L), - Rssi(4L), - BeaconLostCount(5L), - BeaconRxCount(6L), - PacketMulticastRxCount(7L), - PacketMulticastTxCount(8L), - PacketUnicastRxCount(9L), - PacketUnicastTxCount(10L), - CurrentMaxRate(11L), - OverrunCount(12L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - Disconnection(0L), - AssociationFailure(1L), - ConnectionStatus(2L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCounts(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class EthernetNetworkDiagnostics implements BaseCluster { - public static final long ID = 55L; - - public long getID() { - return ID; - } - - public enum Attribute { - PHYRate(0L), - FullDuplex(1L), - PacketRxCount(2L), - PacketTxCount(3L), - TxErrCount(4L), - CollisionCount(5L), - OverrunCount(6L), - CarrierDetect(7L), - TimeSinceReset(8L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCounts(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class TimeSynchronization implements BaseCluster { - public static final long ID = 56L; - - public long getID() { - return ID; - } - - public enum Attribute { - UTCTime(0L), - Granularity(1L), - TimeSource(2L), - TrustedTimeSource(3L), - DefaultNTP(4L), - TimeZone(5L), - DSTOffset(6L), - LocalTime(7L), - TimeZoneDatabase(8L), - NTPServerAvailable(9L), - TimeZoneListMaxSize(10L), - DSTOffsetListMaxSize(11L), - SupportsDNSResolve(12L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - DSTTableEmpty(0L), - DSTStatus(1L), - TimeZoneStatus(2L), - TimeFailure(3L), - MissingTrustedTimeSource(4L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SetUTCTime(0L), - SetTrustedTimeSource(1L), - SetTimeZone(2L), - SetDSTOffset(4L), - SetDefaultNTP(5L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetUTCTimeCommandField { - UTCTime(0), - Granularity(1), - TimeSource(2), - ; - private final int id; - - SetUTCTimeCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetUTCTimeCommandField value(int id) throws NoSuchFieldError { - for (SetUTCTimeCommandField field : SetUTCTimeCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetTrustedTimeSourceCommandField { - TrustedTimeSource(0), - ; - private final int id; - - SetTrustedTimeSourceCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetTrustedTimeSourceCommandField value(int id) throws NoSuchFieldError { - for (SetTrustedTimeSourceCommandField field : SetTrustedTimeSourceCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetTimeZoneCommandField { - TimeZone(0), - ; - private final int id; - - SetTimeZoneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetTimeZoneCommandField value(int id) throws NoSuchFieldError { - for (SetTimeZoneCommandField field : SetTimeZoneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetDSTOffsetCommandField { - DSTOffset(0), - ; - private final int id; - - SetDSTOffsetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetDSTOffsetCommandField value(int id) throws NoSuchFieldError { - for (SetDSTOffsetCommandField field : SetDSTOffsetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetDefaultNTPCommandField { - DefaultNTP(0), - ; - private final int id; - - SetDefaultNTPCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetDefaultNTPCommandField value(int id) throws NoSuchFieldError { - for (SetDefaultNTPCommandField field : SetDefaultNTPCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class BridgedDeviceBasicInformation implements BaseCluster { - public static final long ID = 57L; - - public long getID() { - return ID; - } - - public enum Attribute { - VendorName(1L), - VendorID(2L), - ProductName(3L), - NodeLabel(5L), - HardwareVersion(7L), - HardwareVersionString(8L), - SoftwareVersion(9L), - SoftwareVersionString(10L), - ManufacturingDate(11L), - PartNumber(12L), - ProductURL(13L), - ProductLabel(14L), - SerialNumber(15L), - Reachable(17L), - UniqueID(18L), - ProductAppearance(20L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StartUp(0L), - ShutDown(1L), - Leave(2L), - ReachableChanged(3L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Switch implements BaseCluster { - public static final long ID = 59L; - - public long getID() { - return ID; - } - - public enum Attribute { - NumberOfPositions(0L), - CurrentPosition(1L), - MultiPressMax(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SwitchLatched(0L), - InitialPress(1L), - LongPress(2L), - ShortRelease(3L), - LongRelease(4L), - MultiPressOngoing(5L), - MultiPressComplete(6L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class AdministratorCommissioning implements BaseCluster { - public static final long ID = 60L; - - public long getID() { - return ID; - } - - public enum Attribute { - WindowStatus(0L), - AdminFabricIndex(1L), - AdminVendorId(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - OpenCommissioningWindow(0L), - OpenBasicCommissioningWindow(1L), - RevokeCommissioning(2L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum OpenCommissioningWindowCommandField { - CommissioningTimeout(0), - PAKEPasscodeVerifier(1), - Discriminator(2), - Iterations(3), - Salt(4), - ; - private final int id; - - OpenCommissioningWindowCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static OpenCommissioningWindowCommandField value(int id) throws NoSuchFieldError { - for (OpenCommissioningWindowCommandField field : - OpenCommissioningWindowCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum OpenBasicCommissioningWindowCommandField { - CommissioningTimeout(0), - ; - private final int id; - - OpenBasicCommissioningWindowCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static OpenBasicCommissioningWindowCommandField value(int id) throws NoSuchFieldError { - for (OpenBasicCommissioningWindowCommandField field : - OpenBasicCommissioningWindowCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OperationalCredentials implements BaseCluster { - public static final long ID = 62L; - - public long getID() { - return ID; - } - - public enum Attribute { - NOCs(0L), - Fabrics(1L), - SupportedFabrics(2L), - CommissionedFabrics(3L), - TrustedRootCertificates(4L), - CurrentFabricIndex(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AttestationRequest(0L), - CertificateChainRequest(2L), - CSRRequest(4L), - AddNOC(6L), - UpdateNOC(7L), - UpdateFabricLabel(9L), - RemoveFabric(10L), - AddTrustedRootCertificate(11L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AttestationRequestCommandField { - AttestationNonce(0), - ; - private final int id; - - AttestationRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AttestationRequestCommandField value(int id) throws NoSuchFieldError { - for (AttestationRequestCommandField field : AttestationRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum CertificateChainRequestCommandField { - CertificateType(0), - ; - private final int id; - - CertificateChainRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static CertificateChainRequestCommandField value(int id) throws NoSuchFieldError { - for (CertificateChainRequestCommandField field : - CertificateChainRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum CSRRequestCommandField { - CSRNonce(0), - IsForUpdateNOC(1), - ; - private final int id; - - CSRRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static CSRRequestCommandField value(int id) throws NoSuchFieldError { - for (CSRRequestCommandField field : CSRRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AddNOCCommandField { - NOCValue(0), - ICACValue(1), - IPKValue(2), - CaseAdminSubject(3), - AdminVendorId(4), - ; - private final int id; - - AddNOCCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddNOCCommandField value(int id) throws NoSuchFieldError { - for (AddNOCCommandField field : AddNOCCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum UpdateNOCCommandField { - NOCValue(0), - ICACValue(1), - ; - private final int id; - - UpdateNOCCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static UpdateNOCCommandField value(int id) throws NoSuchFieldError { - for (UpdateNOCCommandField field : UpdateNOCCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum UpdateFabricLabelCommandField { - Label(0), - ; - private final int id; - - UpdateFabricLabelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static UpdateFabricLabelCommandField value(int id) throws NoSuchFieldError { - for (UpdateFabricLabelCommandField field : UpdateFabricLabelCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum RemoveFabricCommandField { - FabricIndex(0), - ; - private final int id; - - RemoveFabricCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RemoveFabricCommandField value(int id) throws NoSuchFieldError { - for (RemoveFabricCommandField field : RemoveFabricCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum AddTrustedRootCertificateCommandField { - RootCACertificate(0), - ; - private final int id; - - AddTrustedRootCertificateCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static AddTrustedRootCertificateCommandField value(int id) throws NoSuchFieldError { - for (AddTrustedRootCertificateCommandField field : - AddTrustedRootCertificateCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class GroupKeyManagement implements BaseCluster { - public static final long ID = 63L; - - public long getID() { - return ID; - } - - public enum Attribute { - GroupKeyMap(0L), - GroupTable(1L), - MaxGroupsPerFabric(2L), - MaxGroupKeysPerFabric(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - KeySetWrite(0L), - KeySetRead(1L), - KeySetRemove(3L), - KeySetReadAllIndices(4L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum KeySetWriteCommandField { - GroupKeySet(0), - ; - private final int id; - - KeySetWriteCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static KeySetWriteCommandField value(int id) throws NoSuchFieldError { - for (KeySetWriteCommandField field : KeySetWriteCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum KeySetReadCommandField { - GroupKeySetID(0), - ; - private final int id; - - KeySetReadCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static KeySetReadCommandField value(int id) throws NoSuchFieldError { - for (KeySetReadCommandField field : KeySetReadCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum KeySetRemoveCommandField { - GroupKeySetID(0), - ; - private final int id; - - KeySetRemoveCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static KeySetRemoveCommandField value(int id) throws NoSuchFieldError { - for (KeySetRemoveCommandField field : KeySetRemoveCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum KeySetReadAllIndicesCommandField { - GroupKeySetIDs(0), - ; - private final int id; - - KeySetReadAllIndicesCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static KeySetReadAllIndicesCommandField value(int id) throws NoSuchFieldError { - for (KeySetReadAllIndicesCommandField field : KeySetReadAllIndicesCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class FixedLabel implements BaseCluster { - public static final long ID = 64L; - - public long getID() { - return ID; - } - - public enum Attribute { - LabelList(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class UserLabel implements BaseCluster { - public static final long ID = 65L; - - public long getID() { - return ID; - } - - public enum Attribute { - LabelList(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ProxyConfiguration implements BaseCluster { - public static final long ID = 66L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ProxyDiscovery implements BaseCluster { - public static final long ID = 67L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ProxyValid implements BaseCluster { - public static final long ID = 68L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class BooleanState implements BaseCluster { - public static final long ID = 69L; - - public long getID() { - return ID; - } - - public enum Attribute { - StateValue(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StateChange(0L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class IcdManagement implements BaseCluster { - public static final long ID = 70L; - - public long getID() { - return ID; - } - - public enum Attribute { - IdleModeInterval(0L), - ActiveModeInterval(1L), - ActiveModeThreshold(2L), - RegisteredClients(3L), - ICDCounter(4L), - ClientsSupportedPerFabric(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - RegisterClient(0L), - UnregisterClient(2L), - StayActiveRequest(3L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum RegisterClientCommandField { - CheckInNodeID(0), - MonitoredSubject(1), - Key(2), - VerificationKey(3), - ; - private final int id; - - RegisterClientCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RegisterClientCommandField value(int id) throws NoSuchFieldError { - for (RegisterClientCommandField field : RegisterClientCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum UnregisterClientCommandField { - CheckInNodeID(0), - Key(1), - ; - private final int id; - - UnregisterClientCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static UnregisterClientCommandField value(int id) throws NoSuchFieldError { - for (UnregisterClientCommandField field : UnregisterClientCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ModeSelect implements BaseCluster { - public static final long ID = 80L; - - public long getID() { - return ID; - } - - public enum Attribute { - Description(0L), - StandardNamespace(1L), - SupportedModes(2L), - CurrentMode(3L), - StartUpMode(4L), - OnMode(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ChangeToMode(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ChangeToModeCommandField { - NewMode(0), - ; - private final int id; - - ChangeToModeCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ChangeToModeCommandField value(int id) throws NoSuchFieldError { - for (ChangeToModeCommandField field : ChangeToModeCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class TemperatureControl implements BaseCluster { - public static final long ID = 86L; - - public long getID() { - return ID; - } - - public enum Attribute { - TemperatureSetpoint(0L), - MinTemperature(1L), - MaxTemperature(2L), - Step(3L), - CurrentTemperatureLevelIndex(4L), - SupportedTemperatureLevels(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SetTemperature(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetTemperatureCommandField { - TargetTemperature(0), - TargetTemperatureLevel(1), - ; - private final int id; - - SetTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetTemperatureCommandField value(int id) throws NoSuchFieldError { - for (SetTemperatureCommandField field : SetTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class RefrigeratorAlarm implements BaseCluster { - public static final long ID = 87L; - - public long getID() { - return ID; - } - - public enum Attribute { - Mask(0L), - Latch(1L), - State(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - Notify(0L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Reset(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ResetCommandField { - Alarms(0), - Mask(1), - ; - private final int id; - - ResetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ResetCommandField value(int id) throws NoSuchFieldError { - for (ResetCommandField field : ResetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class AirQuality implements BaseCluster { - public static final long ID = 91L; - - public long getID() { - return ID; - } - - public enum Attribute { - AirQuality(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class SmokeCoAlarm implements BaseCluster { - public static final long ID = 92L; - - public long getID() { - return ID; - } - - public enum Attribute { - ExpressedState(0L), - SmokeState(1L), - COState(2L), - BatteryAlert(3L), - DeviceMuted(4L), - TestInProgress(5L), - HardwareFaultAlert(6L), - EndOfServiceAlert(7L), - InterconnectSmokeAlarm(8L), - InterconnectCOAlarm(9L), - ContaminationState(10L), - SensitivityLevel(11L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SmokeAlarm(0L), - COAlarm(1L), - LowBattery(2L), - HardwareFault(3L), - EndOfService(4L), - SelfTestComplete(5L), - AlarmMuted(6L), - MuteEnded(7L), - InterconnectSmokeAlarm(8L), - InterconnectCOAlarm(9L), - AllClear(10L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SelfTestRequest(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class DishwasherAlarm implements BaseCluster { - public static final long ID = 93L; - - public long getID() { - return ID; - } - - public enum Attribute { - Mask(0L), - Latch(1L), - State(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - Notify(0L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Reset(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ResetCommandField { - Alarms(0), - Mask(1), - ; - private final int id; - - ResetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ResetCommandField value(int id) throws NoSuchFieldError { - for (ResetCommandField field : ResetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class HepaFilterMonitoring implements BaseCluster { - public static final long ID = 113L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ActivatedCarbonFilterMonitoring implements BaseCluster { - public static final long ID = 114L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class CeramicFilterMonitoring implements BaseCluster { - public static final long ID = 115L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ElectrostaticFilterMonitoring implements BaseCluster { - public static final long ID = 116L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class UvFilterMonitoring implements BaseCluster { - public static final long ID = 117L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class IonizingFilterMonitoring implements BaseCluster { - public static final long ID = 118L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ZeoliteFilterMonitoring implements BaseCluster { - public static final long ID = 119L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OzoneFilterMonitoring implements BaseCluster { - public static final long ID = 120L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class WaterTankMonitoring implements BaseCluster { - public static final long ID = 121L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class FuelTankMonitoring implements BaseCluster { - public static final long ID = 122L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class InkCartridgeMonitoring implements BaseCluster { - public static final long ID = 123L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class TonerCartridgeMonitoring implements BaseCluster { - public static final long ID = 124L; - - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class DoorLock implements BaseCluster { - public static final long ID = 257L; - - public long getID() { - return ID; - } - - public enum Attribute { - LockState(0L), - LockType(1L), - ActuatorEnabled(2L), - DoorState(3L), - DoorOpenEvents(4L), - DoorClosedEvents(5L), - OpenPeriod(6L), - NumberOfTotalUsersSupported(17L), - NumberOfPINUsersSupported(18L), - NumberOfRFIDUsersSupported(19L), - NumberOfWeekDaySchedulesSupportedPerUser(20L), - NumberOfYearDaySchedulesSupportedPerUser(21L), - NumberOfHolidaySchedulesSupported(22L), - MaxPINCodeLength(23L), - MinPINCodeLength(24L), - MaxRFIDCodeLength(25L), - MinRFIDCodeLength(26L), - CredentialRulesSupport(27L), - NumberOfCredentialsSupportedPerUser(28L), - Language(33L), - LEDSettings(34L), - AutoRelockTime(35L), - SoundVolume(36L), - OperatingMode(37L), - SupportedOperatingModes(38L), - DefaultConfigurationRegister(39L), - EnableLocalProgramming(40L), - EnableOneTouchLocking(41L), - EnableInsideStatusLED(42L), - EnablePrivacyModeButton(43L), - LocalProgrammingFeatures(44L), - WrongCodeEntryLimit(48L), - UserCodeTemporaryDisableTime(49L), - SendPINOverTheAir(50L), - RequirePINforRemoteOperation(51L), - ExpiringUserTimeout(53L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - DoorLockAlarm(0L), - DoorStateChange(1L), - LockOperation(2L), - LockOperationError(3L), - LockUserChange(4L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - LockDoor(0L), - UnlockDoor(1L), - UnlockWithTimeout(3L), - SetWeekDaySchedule(11L), - GetWeekDaySchedule(12L), - ClearWeekDaySchedule(13L), - SetYearDaySchedule(14L), - GetYearDaySchedule(15L), - ClearYearDaySchedule(16L), - SetHolidaySchedule(17L), - GetHolidaySchedule(18L), - ClearHolidaySchedule(19L), - SetUser(26L), - GetUser(27L), - ClearUser(29L), - SetCredential(34L), - GetCredentialStatus(36L), - ClearCredential(38L), - UnboltDoor(39L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum LockDoorCommandField { - PINCode(0), - ; - private final int id; - - LockDoorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static LockDoorCommandField value(int id) throws NoSuchFieldError { - for (LockDoorCommandField field : LockDoorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum UnlockDoorCommandField { - PINCode(0), - ; - private final int id; - - UnlockDoorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static UnlockDoorCommandField value(int id) throws NoSuchFieldError { - for (UnlockDoorCommandField field : UnlockDoorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum UnlockWithTimeoutCommandField { - Timeout(0), - PINCode(1), - ; - private final int id; - - UnlockWithTimeoutCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static UnlockWithTimeoutCommandField value(int id) throws NoSuchFieldError { - for (UnlockWithTimeoutCommandField field : UnlockWithTimeoutCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetWeekDayScheduleCommandField { - WeekDayIndex(0), - UserIndex(1), - DaysMask(2), - StartHour(3), - StartMinute(4), - EndHour(5), - EndMinute(6), - ; - private final int id; - - SetWeekDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetWeekDayScheduleCommandField field : SetWeekDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetWeekDayScheduleCommandField { - WeekDayIndex(0), - UserIndex(1), - ; - private final int id; - - GetWeekDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetWeekDayScheduleCommandField field : GetWeekDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ClearWeekDayScheduleCommandField { - WeekDayIndex(0), - UserIndex(1), - ; - private final int id; - - ClearWeekDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ClearWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (ClearWeekDayScheduleCommandField field : ClearWeekDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetYearDayScheduleCommandField { - YearDayIndex(0), - UserIndex(1), - LocalStartTime(2), - LocalEndTime(3), - ; - private final int id; - - SetYearDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetYearDayScheduleCommandField field : SetYearDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetYearDayScheduleCommandField { - YearDayIndex(0), - UserIndex(1), - ; - private final int id; - - GetYearDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetYearDayScheduleCommandField field : GetYearDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ClearYearDayScheduleCommandField { - YearDayIndex(0), - UserIndex(1), - ; - private final int id; - - ClearYearDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ClearYearDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (ClearYearDayScheduleCommandField field : ClearYearDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetHolidayScheduleCommandField { - HolidayIndex(0), - LocalStartTime(1), - LocalEndTime(2), - OperatingMode(3), - ; - private final int id; - - SetHolidayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetHolidayScheduleCommandField field : SetHolidayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetHolidayScheduleCommandField { - HolidayIndex(0), - ; - private final int id; - - GetHolidayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetHolidayScheduleCommandField field : GetHolidayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ClearHolidayScheduleCommandField { - HolidayIndex(0), - ; - private final int id; - - ClearHolidayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ClearHolidayScheduleCommandField value(int id) throws NoSuchFieldError { - for (ClearHolidayScheduleCommandField field : ClearHolidayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetUserCommandField { - OperationType(0), - UserIndex(1), - UserName(2), - UserUniqueID(3), - UserStatus(4), - UserType(5), - CredentialRule(6), - ; - private final int id; - - SetUserCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetUserCommandField value(int id) throws NoSuchFieldError { - for (SetUserCommandField field : SetUserCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetUserCommandField { - UserIndex(0), - ; - private final int id; - - GetUserCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetUserCommandField value(int id) throws NoSuchFieldError { - for (GetUserCommandField field : GetUserCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ClearUserCommandField { - UserIndex(0), - ; - private final int id; - - ClearUserCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ClearUserCommandField value(int id) throws NoSuchFieldError { - for (ClearUserCommandField field : ClearUserCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetCredentialCommandField { - OperationType(0), - Credential(1), - CredentialData(2), - UserIndex(3), - UserStatus(4), - UserType(5), - ; - private final int id; - - SetCredentialCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetCredentialCommandField value(int id) throws NoSuchFieldError { - for (SetCredentialCommandField field : SetCredentialCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetCredentialStatusCommandField { - Credential(0), - ; - private final int id; - - GetCredentialStatusCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetCredentialStatusCommandField value(int id) throws NoSuchFieldError { - for (GetCredentialStatusCommandField field : GetCredentialStatusCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ClearCredentialCommandField { - Credential(0), - ; - private final int id; - - ClearCredentialCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ClearCredentialCommandField value(int id) throws NoSuchFieldError { - for (ClearCredentialCommandField field : ClearCredentialCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum UnboltDoorCommandField { - PINCode(0), - ; - private final int id; - - UnboltDoorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static UnboltDoorCommandField value(int id) throws NoSuchFieldError { - for (UnboltDoorCommandField field : UnboltDoorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class WindowCovering implements BaseCluster { - public static final long ID = 258L; - - public long getID() { - return ID; - } - - public enum Attribute { - Type(0L), - PhysicalClosedLimitLift(1L), - PhysicalClosedLimitTilt(2L), - CurrentPositionLift(3L), - CurrentPositionTilt(4L), - NumberOfActuationsLift(5L), - NumberOfActuationsTilt(6L), - ConfigStatus(7L), - CurrentPositionLiftPercentage(8L), - CurrentPositionTiltPercentage(9L), - OperationalStatus(10L), - TargetPositionLiftPercent100ths(11L), - TargetPositionTiltPercent100ths(12L), - EndProductType(13L), - CurrentPositionLiftPercent100ths(14L), - CurrentPositionTiltPercent100ths(15L), - InstalledOpenLimitLift(16L), - InstalledClosedLimitLift(17L), - InstalledOpenLimitTilt(18L), - InstalledClosedLimitTilt(19L), - Mode(23L), - SafetyStatus(26L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - UpOrOpen(0L), - DownOrClose(1L), - StopMotion(2L), - GoToLiftValue(4L), - GoToLiftPercentage(5L), - GoToTiltValue(7L), - GoToTiltPercentage(8L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GoToLiftValueCommandField { - LiftValue(0), - ; - private final int id; - - GoToLiftValueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GoToLiftValueCommandField value(int id) throws NoSuchFieldError { - for (GoToLiftValueCommandField field : GoToLiftValueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GoToLiftPercentageCommandField { - LiftPercent100thsValue(0), - ; - private final int id; - - GoToLiftPercentageCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GoToLiftPercentageCommandField value(int id) throws NoSuchFieldError { - for (GoToLiftPercentageCommandField field : GoToLiftPercentageCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GoToTiltValueCommandField { - TiltValue(0), - ; - private final int id; - - GoToTiltValueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GoToTiltValueCommandField value(int id) throws NoSuchFieldError { - for (GoToTiltValueCommandField field : GoToTiltValueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GoToTiltPercentageCommandField { - TiltPercent100thsValue(0), - ; - private final int id; - - GoToTiltPercentageCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GoToTiltPercentageCommandField value(int id) throws NoSuchFieldError { - for (GoToTiltPercentageCommandField field : GoToTiltPercentageCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class BarrierControl implements BaseCluster { - public static final long ID = 259L; - - public long getID() { - return ID; - } - - public enum Attribute { - BarrierMovingState(1L), - BarrierSafetyStatus(2L), - BarrierCapabilities(3L), - BarrierOpenEvents(4L), - BarrierCloseEvents(5L), - BarrierCommandOpenEvents(6L), - BarrierCommandCloseEvents(7L), - BarrierOpenPeriod(8L), - BarrierClosePeriod(9L), - BarrierPosition(10L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - BarrierControlGoToPercent(0L), - BarrierControlStop(1L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum BarrierControlGoToPercentCommandField { - PercentOpen(0), - ; - private final int id; - - BarrierControlGoToPercentCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static BarrierControlGoToPercentCommandField value(int id) throws NoSuchFieldError { - for (BarrierControlGoToPercentCommandField field : - BarrierControlGoToPercentCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class PumpConfigurationAndControl implements BaseCluster { - public static final long ID = 512L; - - public long getID() { - return ID; - } - - public enum Attribute { - MaxPressure(0L), - MaxSpeed(1L), - MaxFlow(2L), - MinConstPressure(3L), - MaxConstPressure(4L), - MinCompPressure(5L), - MaxCompPressure(6L), - MinConstSpeed(7L), - MaxConstSpeed(8L), - MinConstFlow(9L), - MaxConstFlow(10L), - MinConstTemp(11L), - MaxConstTemp(12L), - PumpStatus(16L), - EffectiveOperationMode(17L), - EffectiveControlMode(18L), - Capacity(19L), - Speed(20L), - LifetimeRunningHours(21L), - Power(22L), - LifetimeEnergyConsumed(23L), - OperationMode(32L), - ControlMode(33L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SupplyVoltageLow(0L), - SupplyVoltageHigh(1L), - PowerMissingPhase(2L), - SystemPressureLow(3L), - SystemPressureHigh(4L), - DryRunning(5L), - MotorTemperatureHigh(6L), - PumpMotorFatalFailure(7L), - ElectronicTemperatureHigh(8L), - PumpBlocked(9L), - SensorFailure(10L), - ElectronicNonFatalFailure(11L), - ElectronicFatalFailure(12L), - GeneralFault(13L), - Leakage(14L), - AirDetection(15L), - TurbineOperation(16L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Thermostat implements BaseCluster { - public static final long ID = 513L; - - public long getID() { - return ID; - } - - public enum Attribute { - LocalTemperature(0L), - OutdoorTemperature(1L), - Occupancy(2L), - AbsMinHeatSetpointLimit(3L), - AbsMaxHeatSetpointLimit(4L), - AbsMinCoolSetpointLimit(5L), - AbsMaxCoolSetpointLimit(6L), - PICoolingDemand(7L), - PIHeatingDemand(8L), - HVACSystemTypeConfiguration(9L), - LocalTemperatureCalibration(16L), - OccupiedCoolingSetpoint(17L), - OccupiedHeatingSetpoint(18L), - UnoccupiedCoolingSetpoint(19L), - UnoccupiedHeatingSetpoint(20L), - MinHeatSetpointLimit(21L), - MaxHeatSetpointLimit(22L), - MinCoolSetpointLimit(23L), - MaxCoolSetpointLimit(24L), - MinSetpointDeadBand(25L), - RemoteSensing(26L), - ControlSequenceOfOperation(27L), - SystemMode(28L), - ThermostatRunningMode(30L), - StartOfWeek(32L), - NumberOfWeeklyTransitions(33L), - NumberOfDailyTransitions(34L), - TemperatureSetpointHold(35L), - TemperatureSetpointHoldDuration(36L), - ThermostatProgrammingOperationMode(37L), - ThermostatRunningState(41L), - SetpointChangeSource(48L), - SetpointChangeAmount(49L), - SetpointChangeSourceTimestamp(50L), - OccupiedSetback(52L), - OccupiedSetbackMin(53L), - OccupiedSetbackMax(54L), - UnoccupiedSetback(55L), - UnoccupiedSetbackMin(56L), - UnoccupiedSetbackMax(57L), - EmergencyHeatDelta(58L), - ACType(64L), - ACCapacity(65L), - ACRefrigerantType(66L), - ACCompressorType(67L), - ACErrorCode(68L), - ACLouverPosition(69L), - ACCoilTemperature(70L), - ACCapacityformat(71L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SetpointRaiseLower(0L), - SetWeeklySchedule(1L), - GetWeeklySchedule(2L), - ClearWeeklySchedule(3L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetpointRaiseLowerCommandField { - Mode(0), - Amount(1), - ; - private final int id; - - SetpointRaiseLowerCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetpointRaiseLowerCommandField value(int id) throws NoSuchFieldError { - for (SetpointRaiseLowerCommandField field : SetpointRaiseLowerCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SetWeeklyScheduleCommandField { - NumberOfTransitionsForSequence(0), - DayOfWeekForSequence(1), - ModeForSequence(2), - Transitions(3), - ; - private final int id; - - SetWeeklyScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetWeeklyScheduleCommandField field : SetWeeklyScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetWeeklyScheduleCommandField { - DaysToReturn(0), - ModeToReturn(1), - ; - private final int id; - - GetWeeklyScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetWeeklyScheduleCommandField field : GetWeeklyScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class FanControl implements BaseCluster { - public static final long ID = 514L; - - public long getID() { - return ID; - } - - public enum Attribute { - FanMode(0L), - FanModeSequence(1L), - PercentSetting(2L), - PercentCurrent(3L), - SpeedMax(4L), - SpeedSetting(5L), - SpeedCurrent(6L), - RockSupport(7L), - RockSetting(8L), - WindSupport(9L), - WindSetting(10L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ThermostatUserInterfaceConfiguration implements BaseCluster { - public static final long ID = 516L; - - public long getID() { - return ID; - } - - public enum Attribute { - TemperatureDisplayMode(0L), - KeypadLockout(1L), - ScheduleProgrammingVisibility(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ColorControl implements BaseCluster { - public static final long ID = 768L; - - public long getID() { - return ID; - } - - public enum Attribute { - CurrentHue(0L), - CurrentSaturation(1L), - RemainingTime(2L), - CurrentX(3L), - CurrentY(4L), - DriftCompensation(5L), - CompensationText(6L), - ColorTemperatureMireds(7L), - ColorMode(8L), - Options(15L), - NumberOfPrimaries(16L), - Primary1X(17L), - Primary1Y(18L), - Primary1Intensity(19L), - Primary2X(21L), - Primary2Y(22L), - Primary2Intensity(23L), - Primary3X(25L), - Primary3Y(26L), - Primary3Intensity(27L), - Primary4X(32L), - Primary4Y(33L), - Primary4Intensity(34L), - Primary5X(36L), - Primary5Y(37L), - Primary5Intensity(38L), - Primary6X(40L), - Primary6Y(41L), - Primary6Intensity(42L), - WhitePointX(48L), - WhitePointY(49L), - ColorPointRX(50L), - ColorPointRY(51L), - ColorPointRIntensity(52L), - ColorPointGX(54L), - ColorPointGY(55L), - ColorPointGIntensity(56L), - ColorPointBX(58L), - ColorPointBY(59L), - ColorPointBIntensity(60L), - EnhancedCurrentHue(16384L), - EnhancedColorMode(16385L), - ColorLoopActive(16386L), - ColorLoopDirection(16387L), - ColorLoopTime(16388L), - ColorLoopStartEnhancedHue(16389L), - ColorLoopStoredEnhancedHue(16390L), - ColorCapabilities(16394L), - ColorTempPhysicalMinMireds(16395L), - ColorTempPhysicalMaxMireds(16396L), - CoupleColorTempToLevelMinMireds(16397L), - StartUpColorTemperatureMireds(16400L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - MoveToHue(0L), - MoveHue(1L), - StepHue(2L), - MoveToSaturation(3L), - MoveSaturation(4L), - StepSaturation(5L), - MoveToHueAndSaturation(6L), - MoveToColor(7L), - MoveColor(8L), - StepColor(9L), - MoveToColorTemperature(10L), - EnhancedMoveToHue(64L), - EnhancedMoveHue(65L), - EnhancedStepHue(66L), - EnhancedMoveToHueAndSaturation(67L), - ColorLoopSet(68L), - StopMoveStep(71L), - MoveColorTemperature(75L), - StepColorTemperature(76L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToHueCommandField { - Hue(0), - Direction(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - MoveToHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToHueCommandField value(int id) throws NoSuchFieldError { - for (MoveToHueCommandField field : MoveToHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveHueCommandField { - MoveMode(0), - Rate(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveHueCommandField value(int id) throws NoSuchFieldError { - for (MoveHueCommandField field : MoveHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StepHueCommandField { - StepMode(0), - StepSize(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - StepHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StepHueCommandField value(int id) throws NoSuchFieldError { - for (StepHueCommandField field : StepHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToSaturationCommandField { - Saturation(0), - TransitionTime(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveToSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToSaturationCommandField value(int id) throws NoSuchFieldError { - for (MoveToSaturationCommandField field : MoveToSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveSaturationCommandField { - MoveMode(0), - Rate(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveSaturationCommandField value(int id) throws NoSuchFieldError { - for (MoveSaturationCommandField field : MoveSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StepSaturationCommandField { - StepMode(0), - StepSize(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - StepSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StepSaturationCommandField value(int id) throws NoSuchFieldError { - for (StepSaturationCommandField field : StepSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToHueAndSaturationCommandField { - Hue(0), - Saturation(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - MoveToHueAndSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToHueAndSaturationCommandField value(int id) throws NoSuchFieldError { - for (MoveToHueAndSaturationCommandField field : - MoveToHueAndSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToColorCommandField { - ColorX(0), - ColorY(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - MoveToColorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToColorCommandField value(int id) throws NoSuchFieldError { - for (MoveToColorCommandField field : MoveToColorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveColorCommandField { - RateX(0), - RateY(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveColorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveColorCommandField value(int id) throws NoSuchFieldError { - for (MoveColorCommandField field : MoveColorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StepColorCommandField { - StepX(0), - StepY(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - StepColorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StepColorCommandField value(int id) throws NoSuchFieldError { - for (StepColorCommandField field : StepColorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveToColorTemperatureCommandField { - ColorTemperatureMireds(0), - TransitionTime(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - MoveToColorTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveToColorTemperatureCommandField value(int id) throws NoSuchFieldError { - for (MoveToColorTemperatureCommandField field : - MoveToColorTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnhancedMoveToHueCommandField { - EnhancedHue(0), - Direction(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - EnhancedMoveToHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnhancedMoveToHueCommandField value(int id) throws NoSuchFieldError { - for (EnhancedMoveToHueCommandField field : EnhancedMoveToHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnhancedMoveHueCommandField { - MoveMode(0), - Rate(1), - OptionsMask(2), - OptionsOverride(3), - ; - private final int id; - - EnhancedMoveHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnhancedMoveHueCommandField value(int id) throws NoSuchFieldError { - for (EnhancedMoveHueCommandField field : EnhancedMoveHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnhancedStepHueCommandField { - StepMode(0), - StepSize(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - EnhancedStepHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnhancedStepHueCommandField value(int id) throws NoSuchFieldError { - for (EnhancedStepHueCommandField field : EnhancedStepHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum EnhancedMoveToHueAndSaturationCommandField { - EnhancedHue(0), - Saturation(1), - TransitionTime(2), - OptionsMask(3), - OptionsOverride(4), - ; - private final int id; - - EnhancedMoveToHueAndSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static EnhancedMoveToHueAndSaturationCommandField value(int id) - throws NoSuchFieldError { - for (EnhancedMoveToHueAndSaturationCommandField field : - EnhancedMoveToHueAndSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ColorLoopSetCommandField { - UpdateFlags(0), - Action(1), - Direction(2), - Time(3), - StartHue(4), - OptionsMask(5), - OptionsOverride(6), - ; - private final int id; - - ColorLoopSetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ColorLoopSetCommandField value(int id) throws NoSuchFieldError { - for (ColorLoopSetCommandField field : ColorLoopSetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StopMoveStepCommandField { - OptionsMask(0), - OptionsOverride(1), - ; - private final int id; - - StopMoveStepCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StopMoveStepCommandField value(int id) throws NoSuchFieldError { - for (StopMoveStepCommandField field : StopMoveStepCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum MoveColorTemperatureCommandField { - MoveMode(0), - Rate(1), - ColorTemperatureMinimumMireds(2), - ColorTemperatureMaximumMireds(3), - OptionsMask(4), - OptionsOverride(5), - ; - private final int id; - - MoveColorTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static MoveColorTemperatureCommandField value(int id) throws NoSuchFieldError { - for (MoveColorTemperatureCommandField field : MoveColorTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum StepColorTemperatureCommandField { - StepMode(0), - StepSize(1), - TransitionTime(2), - ColorTemperatureMinimumMireds(3), - ColorTemperatureMaximumMireds(4), - OptionsMask(5), - OptionsOverride(6), - ; - private final int id; - - StepColorTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StepColorTemperatureCommandField value(int id) throws NoSuchFieldError { - for (StepColorTemperatureCommandField field : StepColorTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class BallastConfiguration implements BaseCluster { - public static final long ID = 769L; - - public long getID() { - return ID; - } - - public enum Attribute { - PhysicalMinLevel(0L), - PhysicalMaxLevel(1L), - BallastStatus(2L), - MinLevel(16L), - MaxLevel(17L), - IntrinsicBallastFactor(20L), - BallastFactorAdjustment(21L), - LampQuantity(32L), - LampType(48L), - LampManufacturer(49L), - LampRatedHours(50L), - LampBurnHours(51L), - LampAlarmMode(52L), - LampBurnHoursTripPoint(53L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class IlluminanceMeasurement implements BaseCluster { - public static final long ID = 1024L; - - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - LightSensorType(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == PowerSourceConfiguration.ID) { + return new PowerSourceConfiguration(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class TemperatureMeasurement implements BaseCluster { - public static final long ID = 1026L; - - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == PowerSource.ID) { + return new PowerSource(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == GeneralCommissioning.ID) { + return new GeneralCommissioning(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class PressureMeasurement implements BaseCluster { - public static final long ID = 1027L; - - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - ScaledValue(16L), - MinScaledValue(17L), - MaxScaledValue(18L), - ScaledTolerance(19L), - Scale(20L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == NetworkCommissioning.ID) { + return new NetworkCommissioning(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == DiagnosticLogs.ID) { + return new DiagnosticLogs(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class FlowMeasurement implements BaseCluster { - public static final long ID = 1028L; - - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == GeneralDiagnostics.ID) { + return new GeneralDiagnostics(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == SoftwareDiagnostics.ID) { + return new SoftwareDiagnostics(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class RelativeHumidityMeasurement implements BaseCluster { - public static final long ID = 1029L; - - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == ThreadNetworkDiagnostics.ID) { + return new ThreadNetworkDiagnostics(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == WiFiNetworkDiagnostics.ID) { + return new WiFiNetworkDiagnostics(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class OccupancySensing implements BaseCluster { - public static final long ID = 1030L; - - public long getID() { - return ID; - } - - public enum Attribute { - Occupancy(0L), - OccupancySensorType(1L), - OccupancySensorTypeBitmap(2L), - PIROccupiedToUnoccupiedDelay(16L), - PIRUnoccupiedToOccupiedDelay(17L), - PIRUnoccupiedToOccupiedThreshold(18L), - UltrasonicOccupiedToUnoccupiedDelay(32L), - UltrasonicUnoccupiedToOccupiedDelay(33L), - UltrasonicUnoccupiedToOccupiedThreshold(34L), - PhysicalContactOccupiedToUnoccupiedDelay(48L), - PhysicalContactUnoccupiedToOccupiedDelay(49L), - PhysicalContactUnoccupiedToOccupiedThreshold(50L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == EthernetNetworkDiagnostics.ID) { + return new EthernetNetworkDiagnostics(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == TimeSynchronization.ID) { + return new TimeSynchronization(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class WakeOnLan implements BaseCluster { - public static final long ID = 1283L; - - public long getID() { - return ID; - } - - public enum Attribute { - MACAddress(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == BridgedDeviceBasicInformation.ID) { + return new BridgedDeviceBasicInformation(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == Switch.ID) { + return new Switch(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class Channel implements BaseCluster { - public static final long ID = 1284L; - - public long getID() { - return ID; - } - - public enum Attribute { - ChannelList(0L), - Lineup(1L), - CurrentChannel(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == AdministratorCommissioning.ID) { + return new AdministratorCommissioning(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ChangeChannel(0L), - ChangeChannelByNumber(2L), - SkipChannel(3L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum ChangeChannelCommandField { - Match(0), - ; - private final int id; - - ChangeChannelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ChangeChannelCommandField value(int id) throws NoSuchFieldError { - for (ChangeChannelCommandField field : ChangeChannelCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == OperationalCredentials.ID) { + return new OperationalCredentials(); } - throw new NoSuchFieldError(); - } - } - - public enum ChangeChannelByNumberCommandField { - MajorNumber(0), - MinorNumber(1), - ; - private final int id; - - ChangeChannelByNumberCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static ChangeChannelByNumberCommandField value(int id) throws NoSuchFieldError { - for (ChangeChannelByNumberCommandField field : ChangeChannelByNumberCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == GroupKeyManagement.ID) { + return new GroupKeyManagement(); } - throw new NoSuchFieldError(); - } - } - - public enum SkipChannelCommandField { - Count(0), - ; - private final int id; - - SkipChannelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SkipChannelCommandField value(int id) throws NoSuchFieldError { - for (SkipChannelCommandField field : SkipChannelCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == FixedLabel.ID) { + return new FixedLabel(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class TargetNavigator implements BaseCluster { - public static final long ID = 1285L; - - public long getID() { - return ID; - } - - public enum Attribute { - TargetList(0L), - CurrentTarget(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == UserLabel.ID) { + return new UserLabel(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - NavigateTarget(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == ProxyConfiguration.ID) { + return new ProxyConfiguration(); } - throw new NoSuchFieldError(); - } - } - - public enum NavigateTargetCommandField { - Target(0), - Data(1), - ; - private final int id; - - NavigateTargetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static NavigateTargetCommandField value(int id) throws NoSuchFieldError { - for (NavigateTargetCommandField field : NavigateTargetCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == ProxyDiscovery.ID) { + return new ProxyDiscovery(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class MediaPlayback implements BaseCluster { - public static final long ID = 1286L; - - public long getID() { - return ID; - } - - public enum Attribute { - CurrentState(0L), - StartTime(1L), - Duration(2L), - SampledPosition(3L), - PlaybackSpeed(4L), - SeekRangeEnd(5L), - SeekRangeStart(6L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == ProxyValid.ID) { + return new ProxyValid(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Play(0L), - Pause(1L), - Stop(2L), - StartOver(3L), - Previous(4L), - Next(5L), - Rewind(6L), - FastForward(7L), - SkipForward(8L), - SkipBackward(9L), - Seek(11L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SkipForwardCommandField { - DeltaPositionMilliseconds(0), - ; - private final int id; - - SkipForwardCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SkipForwardCommandField value(int id) throws NoSuchFieldError { - for (SkipForwardCommandField field : SkipForwardCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == BooleanState.ID) { + return new BooleanState(); } - throw new NoSuchFieldError(); - } - } - - public enum SkipBackwardCommandField { - DeltaPositionMilliseconds(0), - ; - private final int id; - - SkipBackwardCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SkipBackwardCommandField value(int id) throws NoSuchFieldError { - for (SkipBackwardCommandField field : SkipBackwardCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == IcdManagement.ID) { + return new IcdManagement(); } - throw new NoSuchFieldError(); - } - } - - public enum SeekCommandField { - Position(0), - ; - private final int id; - - SeekCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SeekCommandField value(int id) throws NoSuchFieldError { - for (SeekCommandField field : SeekCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == ModeSelect.ID) { + return new ModeSelect(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class MediaInput implements BaseCluster { - public static final long ID = 1287L; - - public long getID() { - return ID; - } - - public enum Attribute { - InputList(0L), - CurrentInput(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == TemperatureControl.ID) { + return new TemperatureControl(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SelectInput(0L), - ShowInputStatus(1L), - HideInputStatus(2L), - RenameInput(3L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SelectInputCommandField { - Index(0), - ; - private final int id; - - SelectInputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SelectInputCommandField value(int id) throws NoSuchFieldError { - for (SelectInputCommandField field : SelectInputCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == RefrigeratorAlarm.ID) { + return new RefrigeratorAlarm(); } - throw new NoSuchFieldError(); - } - } - - public enum RenameInputCommandField { - Index(0), - Name(1), - ; - private final int id; - - RenameInputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RenameInputCommandField value(int id) throws NoSuchFieldError { - for (RenameInputCommandField field : RenameInputCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == AirQuality.ID) { + return new AirQuality(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class LowPower implements BaseCluster { - public static final long ID = 1288L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == SmokeCoAlarm.ID) { + return new SmokeCoAlarm(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Sleep(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == DishwasherAlarm.ID) { + return new DishwasherAlarm(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class KeypadInput implements BaseCluster { - public static final long ID = 1289L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == HepaFilterMonitoring.ID) { + return new HepaFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SendKey(0L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == ActivatedCarbonFilterMonitoring.ID) { + return new ActivatedCarbonFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum SendKeyCommandField { - KeyCode(0), - ; - private final int id; - - SendKeyCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SendKeyCommandField value(int id) throws NoSuchFieldError { - for (SendKeyCommandField field : SendKeyCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == CeramicFilterMonitoring.ID) { + return new CeramicFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ContentLauncher implements BaseCluster { - public static final long ID = 1290L; - - public long getID() { - return ID; - } - - public enum Attribute { - AcceptHeader(0L), - SupportedStreamingProtocols(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == ElectrostaticFilterMonitoring.ID) { + return new ElectrostaticFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - LaunchContent(0L), - LaunchURL(1L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == UvFilterMonitoring.ID) { + return new UvFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum LaunchContentCommandField { - Search(0), - AutoPlay(1), - Data(2), - ; - private final int id; - - LaunchContentCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static LaunchContentCommandField value(int id) throws NoSuchFieldError { - for (LaunchContentCommandField field : LaunchContentCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum LaunchURLCommandField { - ContentURL(0), - DisplayString(1), - BrandingInformation(2), - ; - private final int id; - - LaunchURLCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static LaunchURLCommandField value(int id) throws NoSuchFieldError { - for (LaunchURLCommandField field : LaunchURLCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class AudioOutput implements BaseCluster { - public static final long ID = 1291L; - - public long getID() { - return ID; - } - - public enum Attribute { - OutputList(0L), - CurrentOutput(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == IonizingFilterMonitoring.ID) { + return new IonizingFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SelectOutput(0L), - RenameOutput(1L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == ZeoliteFilterMonitoring.ID) { + return new ZeoliteFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum SelectOutputCommandField { - Index(0), - ; - private final int id; - - SelectOutputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SelectOutputCommandField value(int id) throws NoSuchFieldError { - for (SelectOutputCommandField field : SelectOutputCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == OzoneFilterMonitoring.ID) { + return new OzoneFilterMonitoring(); } - throw new NoSuchFieldError(); - } - } - - public enum RenameOutputCommandField { - Index(0), - Name(1), - ; - private final int id; - - RenameOutputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static RenameOutputCommandField value(int id) throws NoSuchFieldError { - for (RenameOutputCommandField field : RenameOutputCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == WaterTankMonitoring.ID) { + return new WaterTankMonitoring(); + } + if (clusterId == FuelTankMonitoring.ID) { + return new FuelTankMonitoring(); + } + if (clusterId == InkCartridgeMonitoring.ID) { + return new InkCartridgeMonitoring(); + } + if (clusterId == TonerCartridgeMonitoring.ID) { + return new TonerCartridgeMonitoring(); + } + if (clusterId == DoorLock.ID) { + return new DoorLock(); + } + if (clusterId == WindowCovering.ID) { + return new WindowCovering(); + } + if (clusterId == BarrierControl.ID) { + return new BarrierControl(); + } + if (clusterId == PumpConfigurationAndControl.ID) { + return new PumpConfigurationAndControl(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ApplicationLauncher implements BaseCluster { - public static final long ID = 1292L; - - public long getID() { - return ID; - } - - public enum Attribute { - CatalogList(0L), - CurrentApp(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == Thermostat.ID) { + return new Thermostat(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - LaunchApp(0L), - StopApp(1L), - HideApp(2L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum LaunchAppCommandField { - Application(0), - Data(1), - ; - private final int id; - - LaunchAppCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static LaunchAppCommandField value(int id) throws NoSuchFieldError { - for (LaunchAppCommandField field : LaunchAppCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == FanControl.ID) { + return new FanControl(); } - throw new NoSuchFieldError(); - } - } - - public enum StopAppCommandField { - Application(0), - ; - private final int id; - - StopAppCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static StopAppCommandField value(int id) throws NoSuchFieldError { - for (StopAppCommandField field : StopAppCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == ThermostatUserInterfaceConfiguration.ID) { + return new ThermostatUserInterfaceConfiguration(); } - throw new NoSuchFieldError(); - } - } - - public enum HideAppCommandField { - Application(0), - ; - private final int id; - - HideAppCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static HideAppCommandField value(int id) throws NoSuchFieldError { - for (HideAppCommandField field : HideAppCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == ColorControl.ID) { + return new ColorControl(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ApplicationBasic implements BaseCluster { - public static final long ID = 1293L; - - public long getID() { - return ID; - } - - public enum Attribute { - VendorName(0L), - VendorID(1L), - ApplicationName(2L), - ProductID(3L), - Application(4L), - Status(5L), - ApplicationVersion(6L), - AllowedVendorList(7L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == BallastConfiguration.ID) { + return new BallastConfiguration(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == IlluminanceMeasurement.ID) { + return new IlluminanceMeasurement(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class AccountLogin implements BaseCluster { - public static final long ID = 1294L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == TemperatureMeasurement.ID) { + return new TemperatureMeasurement(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - GetSetupPIN(0L), - Login(2L), - Logout(3L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum GetSetupPINCommandField { - TempAccountIdentifier(0), - ; - private final int id; - - GetSetupPINCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetSetupPINCommandField value(int id) throws NoSuchFieldError { - for (GetSetupPINCommandField field : GetSetupPINCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == PressureMeasurement.ID) { + return new PressureMeasurement(); } - throw new NoSuchFieldError(); - } - } - - public enum LoginCommandField { - TempAccountIdentifier(0), - SetupPIN(1), - ; - private final int id; - - LoginCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static LoginCommandField value(int id) throws NoSuchFieldError { - for (LoginCommandField field : LoginCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == FlowMeasurement.ID) { + return new FlowMeasurement(); } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class ElectricalMeasurement implements BaseCluster { - public static final long ID = 2820L; - - public long getID() { - return ID; - } - - public enum Attribute { - MeasurementType(0L), - DcVoltage(256L), - DcVoltageMin(257L), - DcVoltageMax(258L), - DcCurrent(259L), - DcCurrentMin(260L), - DcCurrentMax(261L), - DcPower(262L), - DcPowerMin(263L), - DcPowerMax(264L), - DcVoltageMultiplier(512L), - DcVoltageDivisor(513L), - DcCurrentMultiplier(514L), - DcCurrentDivisor(515L), - DcPowerMultiplier(516L), - DcPowerDivisor(517L), - AcFrequency(768L), - AcFrequencyMin(769L), - AcFrequencyMax(770L), - NeutralCurrent(771L), - TotalActivePower(772L), - TotalReactivePower(773L), - TotalApparentPower(774L), - Measured1stHarmonicCurrent(775L), - Measured3rdHarmonicCurrent(776L), - Measured5thHarmonicCurrent(777L), - Measured7thHarmonicCurrent(778L), - Measured9thHarmonicCurrent(779L), - Measured11thHarmonicCurrent(780L), - MeasuredPhase1stHarmonicCurrent(781L), - MeasuredPhase3rdHarmonicCurrent(782L), - MeasuredPhase5thHarmonicCurrent(783L), - MeasuredPhase7thHarmonicCurrent(784L), - MeasuredPhase9thHarmonicCurrent(785L), - MeasuredPhase11thHarmonicCurrent(786L), - AcFrequencyMultiplier(1024L), - AcFrequencyDivisor(1025L), - PowerMultiplier(1026L), - PowerDivisor(1027L), - HarmonicCurrentMultiplier(1028L), - PhaseHarmonicCurrentMultiplier(1029L), - InstantaneousVoltage(1280L), - InstantaneousLineCurrent(1281L), - InstantaneousActiveCurrent(1282L), - InstantaneousReactiveCurrent(1283L), - InstantaneousPower(1284L), - RmsVoltage(1285L), - RmsVoltageMin(1286L), - RmsVoltageMax(1287L), - RmsCurrent(1288L), - RmsCurrentMin(1289L), - RmsCurrentMax(1290L), - ActivePower(1291L), - ActivePowerMin(1292L), - ActivePowerMax(1293L), - ReactivePower(1294L), - ApparentPower(1295L), - PowerFactor(1296L), - AverageRmsVoltageMeasurementPeriod(1297L), - AverageRmsUnderVoltageCounter(1299L), - RmsExtremeOverVoltagePeriod(1300L), - RmsExtremeUnderVoltagePeriod(1301L), - RmsVoltageSagPeriod(1302L), - RmsVoltageSwellPeriod(1303L), - AcVoltageMultiplier(1536L), - AcVoltageDivisor(1537L), - AcCurrentMultiplier(1538L), - AcCurrentDivisor(1539L), - AcPowerMultiplier(1540L), - AcPowerDivisor(1541L), - OverloadAlarmsMask(1792L), - VoltageOverload(1793L), - CurrentOverload(1794L), - AcOverloadAlarmsMask(2048L), - AcVoltageOverload(2049L), - AcCurrentOverload(2050L), - AcActivePowerOverload(2051L), - AcReactivePowerOverload(2052L), - AverageRmsOverVoltage(2053L), - AverageRmsUnderVoltage(2054L), - RmsExtremeOverVoltage(2055L), - RmsExtremeUnderVoltage(2056L), - RmsVoltageSag(2057L), - RmsVoltageSwell(2058L), - LineCurrentPhaseB(2305L), - ActiveCurrentPhaseB(2306L), - ReactiveCurrentPhaseB(2307L), - RmsVoltagePhaseB(2309L), - RmsVoltageMinPhaseB(2310L), - RmsVoltageMaxPhaseB(2311L), - RmsCurrentPhaseB(2312L), - RmsCurrentMinPhaseB(2313L), - RmsCurrentMaxPhaseB(2314L), - ActivePowerPhaseB(2315L), - ActivePowerMinPhaseB(2316L), - ActivePowerMaxPhaseB(2317L), - ReactivePowerPhaseB(2318L), - ApparentPowerPhaseB(2319L), - PowerFactorPhaseB(2320L), - AverageRmsVoltageMeasurementPeriodPhaseB(2321L), - AverageRmsOverVoltageCounterPhaseB(2322L), - AverageRmsUnderVoltageCounterPhaseB(2323L), - RmsExtremeOverVoltagePeriodPhaseB(2324L), - RmsExtremeUnderVoltagePeriodPhaseB(2325L), - RmsVoltageSagPeriodPhaseB(2326L), - RmsVoltageSwellPeriodPhaseB(2327L), - LineCurrentPhaseC(2561L), - ActiveCurrentPhaseC(2562L), - ReactiveCurrentPhaseC(2563L), - RmsVoltagePhaseC(2565L), - RmsVoltageMinPhaseC(2566L), - RmsVoltageMaxPhaseC(2567L), - RmsCurrentPhaseC(2568L), - RmsCurrentMinPhaseC(2569L), - RmsCurrentMaxPhaseC(2570L), - ActivePowerPhaseC(2571L), - ActivePowerMinPhaseC(2572L), - ActivePowerMaxPhaseC(2573L), - ReactivePowerPhaseC(2574L), - ApparentPowerPhaseC(2575L), - PowerFactorPhaseC(2576L), - AverageRmsVoltageMeasurementPeriodPhaseC(2577L), - AverageRmsOverVoltageCounterPhaseC(2578L), - AverageRmsUnderVoltageCounterPhaseC(2579L), - RmsExtremeOverVoltagePeriodPhaseC(2580L), - RmsExtremeUnderVoltagePeriodPhaseC(2581L), - RmsVoltageSagPeriodPhaseC(2582L), - RmsVoltageSwellPeriodPhaseC(2583L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == RelativeHumidityMeasurement.ID) { + return new RelativeHumidityMeasurement(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - GetProfileInfoCommand(0L), - GetMeasurementProfileCommand(1L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == OccupancySensing.ID) { + return new OccupancySensing(); } - throw new NoSuchFieldError(); - } - } - - public enum GetMeasurementProfileCommandCommandField { - AttributeId(0), - StartTime(1), - NumberOfIntervals(2), - ; - private final int id; - - GetMeasurementProfileCommandCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static GetMeasurementProfileCommandCommandField value(int id) throws NoSuchFieldError { - for (GetMeasurementProfileCommandCommandField field : - GetMeasurementProfileCommandCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class UnitTesting implements BaseCluster { - public static final long ID = 4294048773L; - - public long getID() { - return ID; - } - - public enum Attribute { - Boolean(0L), - Bitmap8(1L), - Bitmap16(2L), - Bitmap32(3L), - Bitmap64(4L), - Int8u(5L), - Int16u(6L), - Int24u(7L), - Int32u(8L), - Int40u(9L), - Int48u(10L), - Int56u(11L), - Int64u(12L), - Int8s(13L), - Int16s(14L), - Int24s(15L), - Int32s(16L), - Int40s(17L), - Int48s(18L), - Int56s(19L), - Int64s(20L), - Enum8(21L), - Enum16(22L), - FloatSingle(23L), - FloatDouble(24L), - OctetString(25L), - ListInt8u(26L), - ListOctetString(27L), - ListStructOctetString(28L), - LongOctetString(29L), - CharString(30L), - LongCharString(31L), - EpochUs(32L), - EpochS(33L), - VendorId(34L), - ListNullablesAndOptionalsStruct(35L), - EnumAttr(36L), - StructAttr(37L), - RangeRestrictedInt8u(38L), - RangeRestrictedInt8s(39L), - RangeRestrictedInt16u(40L), - RangeRestrictedInt16s(41L), - ListLongOctetString(42L), - ListFabricScoped(43L), - TimedWriteBoolean(48L), - GeneralErrorBoolean(49L), - ClusterErrorBoolean(50L), - Unsupported(255L), - NullableBoolean(16384L), - NullableBitmap8(16385L), - NullableBitmap16(16386L), - NullableBitmap32(16387L), - NullableBitmap64(16388L), - NullableInt8u(16389L), - NullableInt16u(16390L), - NullableInt24u(16391L), - NullableInt32u(16392L), - NullableInt40u(16393L), - NullableInt48u(16394L), - NullableInt56u(16395L), - NullableInt64u(16396L), - NullableInt8s(16397L), - NullableInt16s(16398L), - NullableInt24s(16399L), - NullableInt32s(16400L), - NullableInt40s(16401L), - NullableInt48s(16402L), - NullableInt56s(16403L), - NullableInt64s(16404L), - NullableEnum8(16405L), - NullableEnum16(16406L), - NullableFloatSingle(16407L), - NullableFloatDouble(16408L), - NullableOctetString(16409L), - NullableCharString(16414L), - NullableEnumAttr(16420L), - NullableStruct(16421L), - NullableRangeRestrictedInt8u(16422L), - NullableRangeRestrictedInt8s(16423L), - NullableRangeRestrictedInt16u(16424L), - NullableRangeRestrictedInt16s(16425L), - WriteOnlyInt8u(16426L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - TestEvent(1L), - TestFabricScopedEvent(2L), - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == WakeOnLan.ID) { + return new WakeOnLan(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Test(0L), - TestNotHandled(1L), - TestSpecific(2L), - TestUnknownCommand(3L), - TestAddArguments(4L), - TestSimpleArgumentRequest(5L), - TestStructArrayArgumentRequest(6L), - TestStructArgumentRequest(7L), - TestNestedStructArgumentRequest(8L), - TestListStructArgumentRequest(9L), - TestListInt8UArgumentRequest(10L), - TestNestedStructListArgumentRequest(11L), - TestListNestedStructListArgumentRequest(12L), - TestListInt8UReverseRequest(13L), - TestEnumsRequest(14L), - TestNullableOptionalRequest(15L), - TestComplexNullableOptionalRequest(16L), - SimpleStructEchoRequest(17L), - TimedInvokeRequest(18L), - TestSimpleOptionalArgumentRequest(19L), - TestEmitTestEventRequest(20L), - TestEmitTestFabricScopedEventRequest(21L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestAddArgumentsCommandField { - Arg1(0), - Arg2(1), - ; - private final int id; - - TestAddArgumentsCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestAddArgumentsCommandField value(int id) throws NoSuchFieldError { - for (TestAddArgumentsCommandField field : TestAddArgumentsCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == Channel.ID) { + return new Channel(); } - throw new NoSuchFieldError(); - } - } - - public enum TestSimpleArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestSimpleArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestSimpleArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestSimpleArgumentRequestCommandField field : - TestSimpleArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == TargetNavigator.ID) { + return new TargetNavigator(); } - throw new NoSuchFieldError(); - } - } - - public enum TestStructArrayArgumentRequestCommandField { - Arg1(0), - Arg2(1), - Arg3(2), - Arg4(3), - Arg5(4), - Arg6(5), - ; - private final int id; - - TestStructArrayArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestStructArrayArgumentRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestStructArrayArgumentRequestCommandField field : - TestStructArrayArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestStructArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestStructArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestStructArgumentRequestCommandField field : - TestStructArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == MediaPlayback.ID) { + return new MediaPlayback(); } - throw new NoSuchFieldError(); - } - } - - public enum TestNestedStructArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestNestedStructArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestNestedStructArgumentRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestNestedStructArgumentRequestCommandField field : - TestNestedStructArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestListStructArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestListStructArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestListStructArgumentRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestListStructArgumentRequestCommandField field : - TestListStructArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestListInt8UArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestListInt8UArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestListInt8UArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestListInt8UArgumentRequestCommandField field : - TestListInt8UArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == MediaInput.ID) { + return new MediaInput(); } - throw new NoSuchFieldError(); - } - } - - public enum TestNestedStructListArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestNestedStructListArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestNestedStructListArgumentRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestNestedStructListArgumentRequestCommandField field : - TestNestedStructListArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestListNestedStructListArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestListNestedStructListArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestListNestedStructListArgumentRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestListNestedStructListArgumentRequestCommandField field : - TestListNestedStructListArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestListInt8UReverseRequestCommandField { - Arg1(0), - ; - private final int id; - - TestListInt8UReverseRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestListInt8UReverseRequestCommandField value(int id) throws NoSuchFieldError { - for (TestListInt8UReverseRequestCommandField field : - TestListInt8UReverseRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == LowPower.ID) { + return new LowPower(); } - throw new NoSuchFieldError(); - } - } - - public enum TestEnumsRequestCommandField { - Arg1(0), - Arg2(1), - ; - private final int id; - - TestEnumsRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestEnumsRequestCommandField value(int id) throws NoSuchFieldError { - for (TestEnumsRequestCommandField field : TestEnumsRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == KeypadInput.ID) { + return new KeypadInput(); } - throw new NoSuchFieldError(); - } - } - - public enum TestNullableOptionalRequestCommandField { - Arg1(0), - ; - private final int id; - - TestNullableOptionalRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestNullableOptionalRequestCommandField value(int id) throws NoSuchFieldError { - for (TestNullableOptionalRequestCommandField field : - TestNullableOptionalRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == ContentLauncher.ID) { + return new ContentLauncher(); } - throw new NoSuchFieldError(); - } - } - - public enum TestComplexNullableOptionalRequestCommandField { - NullableInt(0), - OptionalInt(1), - NullableOptionalInt(2), - NullableString(3), - OptionalString(4), - NullableOptionalString(5), - NullableStruct(6), - OptionalStruct(7), - NullableOptionalStruct(8), - NullableList(9), - OptionalList(10), - NullableOptionalList(11), - ; - private final int id; - - TestComplexNullableOptionalRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestComplexNullableOptionalRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestComplexNullableOptionalRequestCommandField field : - TestComplexNullableOptionalRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum SimpleStructEchoRequestCommandField { - Arg1(0), - ; - private final int id; - - SimpleStructEchoRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static SimpleStructEchoRequestCommandField value(int id) throws NoSuchFieldError { - for (SimpleStructEchoRequestCommandField field : - SimpleStructEchoRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } + if (clusterId == AudioOutput.ID) { + return new AudioOutput(); } - throw new NoSuchFieldError(); - } - } - - public enum TestSimpleOptionalArgumentRequestCommandField { - Arg1(0), - ; - private final int id; - - TestSimpleOptionalArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestSimpleOptionalArgumentRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestSimpleOptionalArgumentRequestCommandField field : - TestSimpleOptionalArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestEmitTestEventRequestCommandField { - Arg1(0), - Arg2(1), - Arg3(2), - ; - private final int id; - - TestEmitTestEventRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestEmitTestEventRequestCommandField value(int id) throws NoSuchFieldError { - for (TestEmitTestEventRequestCommandField field : - TestEmitTestEventRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum TestEmitTestFabricScopedEventRequestCommandField { - Arg1(0), - ; - private final int id; - - TestEmitTestFabricScopedEventRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static TestEmitTestFabricScopedEventRequestCommandField value(int id) - throws NoSuchFieldError { - for (TestEmitTestFabricScopedEventRequestCommandField field : - TestEmitTestFabricScopedEventRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - - public static class FaultInjection implements BaseCluster { - public static final long ID = 4294048774L; - - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L), - ; - private final long id; - - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ; - private final long id; - - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } + if (clusterId == ApplicationLauncher.ID) { + return new ApplicationLauncher(); } - throw new NoSuchFieldError(); - } - } - - public enum Command { - FailAtFault(0L), - FailRandomlyAtFault(1L), - ; - private final long id; - - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } + if (clusterId == ApplicationBasic.ID) { + return new ApplicationBasic(); } - throw new NoSuchFieldError(); - } - } - - public enum FailAtFaultCommandField { - Type(0), - Id(1), - NumCallsToSkip(2), - NumCallsToFail(3), - TakeMutex(4), - ; - private final int id; - - FailAtFaultCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static FailAtFaultCommandField value(int id) throws NoSuchFieldError { - for (FailAtFaultCommandField field : FailAtFaultCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - public enum FailRandomlyAtFaultCommandField { - Type(0), - Id(1), - Percentage(2), - ; - private final int id; - - FailRandomlyAtFaultCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - - public static FailRandomlyAtFaultCommandField value(int id) throws NoSuchFieldError { - for (FailRandomlyAtFaultCommandField field : FailRandomlyAtFaultCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - } - - @Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } -} + if (clusterId == AccountLogin.ID) { + return new AccountLogin(); + } + if (clusterId == ElectricalMeasurement.ID) { + return new ElectricalMeasurement(); + } + if (clusterId == UnitTesting.ID) { + return new UnitTesting(); + } + if (clusterId == FaultInjection.ID) { + return new FaultInjection(); + }return null; + } + public static class Identify implements BaseCluster { + public static final long ID = 3L; + public long getID() { + return ID; + } + + public enum Attribute { + IdentifyTime(0L), + IdentifyType(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Identify(0L), + TriggerEffect(64L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum IdentifyCommandField {IdentifyTime(0),; + private final int id; + IdentifyCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static IdentifyCommandField value(int id) throws NoSuchFieldError { + for (IdentifyCommandField field : IdentifyCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TriggerEffectCommandField {EffectIdentifier(0),EffectVariant(1),; + private final int id; + TriggerEffectCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TriggerEffectCommandField value(int id) throws NoSuchFieldError { + for (TriggerEffectCommandField field : TriggerEffectCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Groups implements BaseCluster { + public static final long ID = 4L; + public long getID() { + return ID; + } + + public enum Attribute { + NameSupport(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + AddGroup(0L), + ViewGroup(1L), + GetGroupMembership(2L), + RemoveGroup(3L), + RemoveAllGroups(4L), + AddGroupIfIdentifying(5L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum AddGroupCommandField {GroupID(0),GroupName(1),; + private final int id; + AddGroupCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddGroupCommandField value(int id) throws NoSuchFieldError { + for (AddGroupCommandField field : AddGroupCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ViewGroupCommandField {GroupID(0),; + private final int id; + ViewGroupCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ViewGroupCommandField value(int id) throws NoSuchFieldError { + for (ViewGroupCommandField field : ViewGroupCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetGroupMembershipCommandField {GroupList(0),; + private final int id; + GetGroupMembershipCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetGroupMembershipCommandField value(int id) throws NoSuchFieldError { + for (GetGroupMembershipCommandField field : GetGroupMembershipCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RemoveGroupCommandField {GroupID(0),; + private final int id; + RemoveGroupCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RemoveGroupCommandField value(int id) throws NoSuchFieldError { + for (RemoveGroupCommandField field : RemoveGroupCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum AddGroupIfIdentifyingCommandField {GroupID(0),GroupName(1),; + private final int id; + AddGroupIfIdentifyingCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddGroupIfIdentifyingCommandField value(int id) throws NoSuchFieldError { + for (AddGroupIfIdentifyingCommandField field : AddGroupIfIdentifyingCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Scenes implements BaseCluster { + public static final long ID = 5L; + public long getID() { + return ID; + } + + public enum Attribute { + SceneCount(0L), + CurrentScene(1L), + CurrentGroup(2L), + SceneValid(3L), + NameSupport(4L), + LastConfiguredBy(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + AddScene(0L), + ViewScene(1L), + RemoveScene(2L), + RemoveAllScenes(3L), + StoreScene(4L), + RecallScene(5L), + GetSceneMembership(6L), + EnhancedAddScene(64L), + EnhancedViewScene(65L), + CopyScene(66L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum AddSceneCommandField {GroupID(0),SceneID(1),TransitionTime(2),SceneName(3),ExtensionFieldSets(4),; + private final int id; + AddSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddSceneCommandField value(int id) throws NoSuchFieldError { + for (AddSceneCommandField field : AddSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ViewSceneCommandField {GroupID(0),SceneID(1),; + private final int id; + ViewSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ViewSceneCommandField value(int id) throws NoSuchFieldError { + for (ViewSceneCommandField field : ViewSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RemoveSceneCommandField {GroupID(0),SceneID(1),; + private final int id; + RemoveSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RemoveSceneCommandField value(int id) throws NoSuchFieldError { + for (RemoveSceneCommandField field : RemoveSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RemoveAllScenesCommandField {GroupID(0),; + private final int id; + RemoveAllScenesCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RemoveAllScenesCommandField value(int id) throws NoSuchFieldError { + for (RemoveAllScenesCommandField field : RemoveAllScenesCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StoreSceneCommandField {GroupID(0),SceneID(1),; + private final int id; + StoreSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StoreSceneCommandField value(int id) throws NoSuchFieldError { + for (StoreSceneCommandField field : StoreSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RecallSceneCommandField {GroupID(0),SceneID(1),TransitionTime(2),; + private final int id; + RecallSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RecallSceneCommandField value(int id) throws NoSuchFieldError { + for (RecallSceneCommandField field : RecallSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetSceneMembershipCommandField {GroupID(0),; + private final int id; + GetSceneMembershipCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetSceneMembershipCommandField value(int id) throws NoSuchFieldError { + for (GetSceneMembershipCommandField field : GetSceneMembershipCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnhancedAddSceneCommandField {GroupID(0),SceneID(1),TransitionTime(2),SceneName(3),ExtensionFieldSets(4),; + private final int id; + EnhancedAddSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnhancedAddSceneCommandField value(int id) throws NoSuchFieldError { + for (EnhancedAddSceneCommandField field : EnhancedAddSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnhancedViewSceneCommandField {GroupID(0),SceneID(1),; + private final int id; + EnhancedViewSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnhancedViewSceneCommandField value(int id) throws NoSuchFieldError { + for (EnhancedViewSceneCommandField field : EnhancedViewSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum CopySceneCommandField {Mode(0),GroupIdentifierFrom(1),SceneIdentifierFrom(2),GroupIdentifierTo(3),SceneIdentifierTo(4),; + private final int id; + CopySceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static CopySceneCommandField value(int id) throws NoSuchFieldError { + for (CopySceneCommandField field : CopySceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OnOff implements BaseCluster { + public static final long ID = 6L; + public long getID() { + return ID; + } + + public enum Attribute { + OnOff(0L), + GlobalSceneControl(16384L), + OnTime(16385L), + OffWaitTime(16386L), + StartUpOnOff(16387L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Off(0L), + On(1L), + Toggle(2L), + OffWithEffect(64L), + OnWithRecallGlobalScene(65L), + OnWithTimedOff(66L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum OffWithEffectCommandField {EffectIdentifier(0),EffectVariant(1),; + private final int id; + OffWithEffectCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static OffWithEffectCommandField value(int id) throws NoSuchFieldError { + for (OffWithEffectCommandField field : OffWithEffectCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum OnWithTimedOffCommandField {OnOffControl(0),OnTime(1),OffWaitTime(2),; + private final int id; + OnWithTimedOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static OnWithTimedOffCommandField value(int id) throws NoSuchFieldError { + for (OnWithTimedOffCommandField field : OnWithTimedOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OnOffSwitchConfiguration implements BaseCluster { + public static final long ID = 7L; + public long getID() { + return ID; + } + + public enum Attribute { + SwitchType(0L), + SwitchActions(16L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class LevelControl implements BaseCluster { + public static final long ID = 8L; + public long getID() { + return ID; + } + + public enum Attribute { + CurrentLevel(0L), + RemainingTime(1L), + MinLevel(2L), + MaxLevel(3L), + CurrentFrequency(4L), + MinFrequency(5L), + MaxFrequency(6L), + Options(15L), + OnOffTransitionTime(16L), + OnLevel(17L), + OnTransitionTime(18L), + OffTransitionTime(19L), + DefaultMoveRate(20L), + StartUpCurrentLevel(16384L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + MoveToLevel(0L), + Move(1L), + Step(2L), + Stop(3L), + MoveToLevelWithOnOff(4L), + MoveWithOnOff(5L), + StepWithOnOff(6L), + StopWithOnOff(7L), + MoveToClosestFrequency(8L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToLevelCommandField {Level(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveToLevelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToLevelCommandField value(int id) throws NoSuchFieldError { + for (MoveToLevelCommandField field : MoveToLevelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveCommandField value(int id) throws NoSuchFieldError { + for (MoveCommandField field : MoveCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StepCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + StepCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StepCommandField value(int id) throws NoSuchFieldError { + for (StepCommandField field : StepCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StopCommandField {OptionsMask(0),OptionsOverride(1),; + private final int id; + StopCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StopCommandField value(int id) throws NoSuchFieldError { + for (StopCommandField field : StopCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToLevelWithOnOffCommandField {Level(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveToLevelWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToLevelWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (MoveToLevelWithOnOffCommandField field : MoveToLevelWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveWithOnOffCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (MoveWithOnOffCommandField field : MoveWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StepWithOnOffCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + StepWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StepWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (StepWithOnOffCommandField field : StepWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StopWithOnOffCommandField {OptionsMask(0),OptionsOverride(1),; + private final int id; + StopWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StopWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (StopWithOnOffCommandField field : StopWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToClosestFrequencyCommandField {Frequency(0),; + private final int id; + MoveToClosestFrequencyCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToClosestFrequencyCommandField value(int id) throws NoSuchFieldError { + for (MoveToClosestFrequencyCommandField field : MoveToClosestFrequencyCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BinaryInputBasic implements BaseCluster { + public static final long ID = 15L; + public long getID() { + return ID; + } + + public enum Attribute { + ActiveText(4L), + Description(28L), + InactiveText(46L), + OutOfService(81L), + Polarity(84L), + PresentValue(85L), + Reliability(103L), + StatusFlags(111L), + ApplicationType(256L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class PulseWidthModulation implements BaseCluster { + public static final long ID = 28L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Descriptor implements BaseCluster { + public static final long ID = 29L; + public long getID() { + return ID; + } + + public enum Attribute { + DeviceTypeList(0L), + ServerList(1L), + ClientList(2L), + PartsList(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Binding implements BaseCluster { + public static final long ID = 30L; + public long getID() { + return ID; + } + + public enum Attribute { + Binding(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class AccessControl implements BaseCluster { + public static final long ID = 31L; + public long getID() { + return ID; + } + + public enum Attribute { + Acl(0L), + Extension(1L), + SubjectsPerAccessControlEntry(2L), + TargetsPerAccessControlEntry(3L), + AccessControlEntriesPerFabric(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + AccessControlEntryChanged(0L), + AccessControlExtensionChanged(1L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Actions implements BaseCluster { + public static final long ID = 37L; + public long getID() { + return ID; + } + + public enum Attribute { + ActionList(0L), + EndpointLists(1L), + SetupURL(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StateChanged(0L), + ActionFailed(1L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + InstantAction(0L), + InstantActionWithTransition(1L), + StartAction(2L), + StartActionWithDuration(3L), + StopAction(4L), + PauseAction(5L), + PauseActionWithDuration(6L), + ResumeAction(7L), + EnableAction(8L), + EnableActionWithDuration(9L), + DisableAction(10L), + DisableActionWithDuration(11L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum InstantActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + InstantActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static InstantActionCommandField value(int id) throws NoSuchFieldError { + for (InstantActionCommandField field : InstantActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum InstantActionWithTransitionCommandField {ActionID(0),InvokeID(1),TransitionTime(2),; + private final int id; + InstantActionWithTransitionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static InstantActionWithTransitionCommandField value(int id) throws NoSuchFieldError { + for (InstantActionWithTransitionCommandField field : InstantActionWithTransitionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StartActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + StartActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StartActionCommandField value(int id) throws NoSuchFieldError { + for (StartActionCommandField field : StartActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StartActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; + private final int id; + StartActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StartActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (StartActionWithDurationCommandField field : StartActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StopActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + StopActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StopActionCommandField value(int id) throws NoSuchFieldError { + for (StopActionCommandField field : StopActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum PauseActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + PauseActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static PauseActionCommandField value(int id) throws NoSuchFieldError { + for (PauseActionCommandField field : PauseActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum PauseActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; + private final int id; + PauseActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static PauseActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (PauseActionWithDurationCommandField field : PauseActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ResumeActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + ResumeActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ResumeActionCommandField value(int id) throws NoSuchFieldError { + for (ResumeActionCommandField field : ResumeActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnableActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + EnableActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnableActionCommandField value(int id) throws NoSuchFieldError { + for (EnableActionCommandField field : EnableActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnableActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; + private final int id; + EnableActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnableActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (EnableActionWithDurationCommandField field : EnableActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum DisableActionCommandField {ActionID(0),InvokeID(1),; + private final int id; + DisableActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static DisableActionCommandField value(int id) throws NoSuchFieldError { + for (DisableActionCommandField field : DisableActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum DisableActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; + private final int id; + DisableActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static DisableActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (DisableActionWithDurationCommandField field : DisableActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BasicInformation implements BaseCluster { + public static final long ID = 40L; + public long getID() { + return ID; + } + + public enum Attribute { + DataModelRevision(0L), + VendorName(1L), + VendorID(2L), + ProductName(3L), + ProductID(4L), + NodeLabel(5L), + Location(6L), + HardwareVersion(7L), + HardwareVersionString(8L), + SoftwareVersion(9L), + SoftwareVersionString(10L), + ManufacturingDate(11L), + PartNumber(12L), + ProductURL(13L), + ProductLabel(14L), + SerialNumber(15L), + LocalConfigDisabled(16L), + Reachable(17L), + UniqueID(18L), + CapabilityMinima(19L), + ProductAppearance(20L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StartUp(0L), + ShutDown(1L), + Leave(2L), + ReachableChanged(3L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + MfgSpecificPing(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OtaSoftwareUpdateProvider implements BaseCluster { + public static final long ID = 41L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + QueryImage(0L), + ApplyUpdateRequest(2L), + NotifyUpdateApplied(4L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum QueryImageCommandField {VendorID(0),ProductID(1),SoftwareVersion(2),ProtocolsSupported(3),HardwareVersion(4),Location(5),RequestorCanConsent(6),MetadataForProvider(7),; + private final int id; + QueryImageCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static QueryImageCommandField value(int id) throws NoSuchFieldError { + for (QueryImageCommandField field : QueryImageCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ApplyUpdateRequestCommandField {UpdateToken(0),NewVersion(1),; + private final int id; + ApplyUpdateRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ApplyUpdateRequestCommandField value(int id) throws NoSuchFieldError { + for (ApplyUpdateRequestCommandField field : ApplyUpdateRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum NotifyUpdateAppliedCommandField {UpdateToken(0),SoftwareVersion(1),; + private final int id; + NotifyUpdateAppliedCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static NotifyUpdateAppliedCommandField value(int id) throws NoSuchFieldError { + for (NotifyUpdateAppliedCommandField field : NotifyUpdateAppliedCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OtaSoftwareUpdateRequestor implements BaseCluster { + public static final long ID = 42L; + public long getID() { + return ID; + } + + public enum Attribute { + DefaultOTAProviders(0L), + UpdatePossible(1L), + UpdateState(2L), + UpdateStateProgress(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StateTransition(0L), + VersionApplied(1L), + DownloadError(2L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + AnnounceOTAProvider(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum AnnounceOTAProviderCommandField {ProviderNodeID(0),VendorID(1),AnnouncementReason(2),MetadataForNode(3),Endpoint(4),; + private final int id; + AnnounceOTAProviderCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AnnounceOTAProviderCommandField value(int id) throws NoSuchFieldError { + for (AnnounceOTAProviderCommandField field : AnnounceOTAProviderCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class LocalizationConfiguration implements BaseCluster { + public static final long ID = 43L; + public long getID() { + return ID; + } + + public enum Attribute { + ActiveLocale(0L), + SupportedLocales(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TimeFormatLocalization implements BaseCluster { + public static final long ID = 44L; + public long getID() { + return ID; + } + + public enum Attribute { + HourFormat(0L), + ActiveCalendarType(1L), + SupportedCalendarTypes(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class UnitLocalization implements BaseCluster { + public static final long ID = 45L; + public long getID() { + return ID; + } + + public enum Attribute { + TemperatureUnit(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class PowerSourceConfiguration implements BaseCluster { + public static final long ID = 46L; + public long getID() { + return ID; + } + + public enum Attribute { + Sources(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class PowerSource implements BaseCluster { + public static final long ID = 47L; + public long getID() { + return ID; + } + + public enum Attribute { + Status(0L), + Order(1L), + Description(2L), + WiredAssessedInputVoltage(3L), + WiredAssessedInputFrequency(4L), + WiredCurrentType(5L), + WiredAssessedCurrent(6L), + WiredNominalVoltage(7L), + WiredMaximumCurrent(8L), + WiredPresent(9L), + ActiveWiredFaults(10L), + BatVoltage(11L), + BatPercentRemaining(12L), + BatTimeRemaining(13L), + BatChargeLevel(14L), + BatReplacementNeeded(15L), + BatReplaceability(16L), + BatPresent(17L), + ActiveBatFaults(18L), + BatReplacementDescription(19L), + BatCommonDesignation(20L), + BatANSIDesignation(21L), + BatIECDesignation(22L), + BatApprovedChemistry(23L), + BatCapacity(24L), + BatQuantity(25L), + BatChargeState(26L), + BatTimeToFullCharge(27L), + BatFunctionalWhileCharging(28L), + BatChargingCurrent(29L), + ActiveBatChargeFaults(30L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + WiredFaultChange(0L), + BatFaultChange(1L), + BatChargeFaultChange(2L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class GeneralCommissioning implements BaseCluster { + public static final long ID = 48L; + public long getID() { + return ID; + } + + public enum Attribute { + Breadcrumb(0L), + BasicCommissioningInfo(1L), + RegulatoryConfig(2L), + LocationCapability(3L), + SupportsConcurrentConnection(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ArmFailSafe(0L), + SetRegulatoryConfig(2L), + CommissioningComplete(4L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum ArmFailSafeCommandField {ExpiryLengthSeconds(0),Breadcrumb(1),; + private final int id; + ArmFailSafeCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ArmFailSafeCommandField value(int id) throws NoSuchFieldError { + for (ArmFailSafeCommandField field : ArmFailSafeCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetRegulatoryConfigCommandField {NewRegulatoryConfig(0),CountryCode(1),Breadcrumb(2),; + private final int id; + SetRegulatoryConfigCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetRegulatoryConfigCommandField value(int id) throws NoSuchFieldError { + for (SetRegulatoryConfigCommandField field : SetRegulatoryConfigCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class NetworkCommissioning implements BaseCluster { + public static final long ID = 49L; + public long getID() { + return ID; + } + + public enum Attribute { + MaxNetworks(0L), + Networks(1L), + ScanMaxTimeSeconds(2L), + ConnectMaxTimeSeconds(3L), + InterfaceEnabled(4L), + LastNetworkingStatus(5L), + LastNetworkID(6L), + LastConnectErrorValue(7L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ScanNetworks(0L), + AddOrUpdateWiFiNetwork(2L), + AddOrUpdateThreadNetwork(3L), + RemoveNetwork(4L), + ConnectNetwork(6L), + ReorderNetwork(8L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum ScanNetworksCommandField {Ssid(0),Breadcrumb(1),; + private final int id; + ScanNetworksCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ScanNetworksCommandField value(int id) throws NoSuchFieldError { + for (ScanNetworksCommandField field : ScanNetworksCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum AddOrUpdateWiFiNetworkCommandField {Ssid(0),Credentials(1),Breadcrumb(2),; + private final int id; + AddOrUpdateWiFiNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddOrUpdateWiFiNetworkCommandField value(int id) throws NoSuchFieldError { + for (AddOrUpdateWiFiNetworkCommandField field : AddOrUpdateWiFiNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum AddOrUpdateThreadNetworkCommandField {OperationalDataset(0),Breadcrumb(1),; + private final int id; + AddOrUpdateThreadNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddOrUpdateThreadNetworkCommandField value(int id) throws NoSuchFieldError { + for (AddOrUpdateThreadNetworkCommandField field : AddOrUpdateThreadNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RemoveNetworkCommandField {NetworkID(0),Breadcrumb(1),; + private final int id; + RemoveNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RemoveNetworkCommandField value(int id) throws NoSuchFieldError { + for (RemoveNetworkCommandField field : RemoveNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ConnectNetworkCommandField {NetworkID(0),Breadcrumb(1),; + private final int id; + ConnectNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ConnectNetworkCommandField value(int id) throws NoSuchFieldError { + for (ConnectNetworkCommandField field : ConnectNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ReorderNetworkCommandField {NetworkID(0),NetworkIndex(1),Breadcrumb(2),; + private final int id; + ReorderNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ReorderNetworkCommandField value(int id) throws NoSuchFieldError { + for (ReorderNetworkCommandField field : ReorderNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class DiagnosticLogs implements BaseCluster { + public static final long ID = 50L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + RetrieveLogsRequest(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum RetrieveLogsRequestCommandField {Intent(0),RequestedProtocol(1),TransferFileDesignator(2),; + private final int id; + RetrieveLogsRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RetrieveLogsRequestCommandField value(int id) throws NoSuchFieldError { + for (RetrieveLogsRequestCommandField field : RetrieveLogsRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class GeneralDiagnostics implements BaseCluster { + public static final long ID = 51L; + public long getID() { + return ID; + } + + public enum Attribute { + NetworkInterfaces(0L), + RebootCount(1L), + UpTime(2L), + TotalOperationalHours(3L), + BootReason(4L), + ActiveHardwareFaults(5L), + ActiveRadioFaults(6L), + ActiveNetworkFaults(7L), + TestEventTriggersEnabled(8L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + HardwareFaultChange(0L), + RadioFaultChange(1L), + NetworkFaultChange(2L), + BootReason(3L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + TestEventTrigger(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum TestEventTriggerCommandField {EnableKey(0),EventTrigger(1),; + private final int id; + TestEventTriggerCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestEventTriggerCommandField value(int id) throws NoSuchFieldError { + for (TestEventTriggerCommandField field : TestEventTriggerCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class SoftwareDiagnostics implements BaseCluster { + public static final long ID = 52L; + public long getID() { + return ID; + } + + public enum Attribute { + ThreadMetrics(0L), + CurrentHeapFree(1L), + CurrentHeapUsed(2L), + CurrentHeapHighWatermark(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SoftwareFault(0L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetWatermarks(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ThreadNetworkDiagnostics implements BaseCluster { + public static final long ID = 53L; + public long getID() { + return ID; + } + + public enum Attribute { + Channel(0L), + RoutingRole(1L), + NetworkName(2L), + PanId(3L), + ExtendedPanId(4L), + MeshLocalPrefix(5L), + OverrunCount(6L), + NeighborTable(7L), + RouteTable(8L), + PartitionId(9L), + Weighting(10L), + DataVersion(11L), + StableDataVersion(12L), + LeaderRouterId(13L), + DetachedRoleCount(14L), + ChildRoleCount(15L), + RouterRoleCount(16L), + LeaderRoleCount(17L), + AttachAttemptCount(18L), + PartitionIdChangeCount(19L), + BetterPartitionAttachAttemptCount(20L), + ParentChangeCount(21L), + TxTotalCount(22L), + TxUnicastCount(23L), + TxBroadcastCount(24L), + TxAckRequestedCount(25L), + TxAckedCount(26L), + TxNoAckRequestedCount(27L), + TxDataCount(28L), + TxDataPollCount(29L), + TxBeaconCount(30L), + TxBeaconRequestCount(31L), + TxOtherCount(32L), + TxRetryCount(33L), + TxDirectMaxRetryExpiryCount(34L), + TxIndirectMaxRetryExpiryCount(35L), + TxErrCcaCount(36L), + TxErrAbortCount(37L), + TxErrBusyChannelCount(38L), + RxTotalCount(39L), + RxUnicastCount(40L), + RxBroadcastCount(41L), + RxDataCount(42L), + RxDataPollCount(43L), + RxBeaconCount(44L), + RxBeaconRequestCount(45L), + RxOtherCount(46L), + RxAddressFilteredCount(47L), + RxDestAddrFilteredCount(48L), + RxDuplicatedCount(49L), + RxErrNoFrameCount(50L), + RxErrUnknownNeighborCount(51L), + RxErrInvalidSrcAddrCount(52L), + RxErrSecCount(53L), + RxErrFcsCount(54L), + RxErrOtherCount(55L), + ActiveTimestamp(56L), + PendingTimestamp(57L), + Delay(58L), + SecurityPolicy(59L), + ChannelPage0Mask(60L), + OperationalDatasetComponents(61L), + ActiveNetworkFaultsList(62L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ConnectionStatus(0L), + NetworkFaultChange(1L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCounts(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class WiFiNetworkDiagnostics implements BaseCluster { + public static final long ID = 54L; + public long getID() { + return ID; + } + + public enum Attribute { + Bssid(0L), + SecurityType(1L), + WiFiVersion(2L), + ChannelNumber(3L), + Rssi(4L), + BeaconLostCount(5L), + BeaconRxCount(6L), + PacketMulticastRxCount(7L), + PacketMulticastTxCount(8L), + PacketUnicastRxCount(9L), + PacketUnicastTxCount(10L), + CurrentMaxRate(11L), + OverrunCount(12L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Disconnection(0L), + AssociationFailure(1L), + ConnectionStatus(2L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCounts(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class EthernetNetworkDiagnostics implements BaseCluster { + public static final long ID = 55L; + public long getID() { + return ID; + } + + public enum Attribute { + PHYRate(0L), + FullDuplex(1L), + PacketRxCount(2L), + PacketTxCount(3L), + TxErrCount(4L), + CollisionCount(5L), + OverrunCount(6L), + CarrierDetect(7L), + TimeSinceReset(8L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCounts(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TimeSynchronization implements BaseCluster { + public static final long ID = 56L; + public long getID() { + return ID; + } + + public enum Attribute { + UTCTime(0L), + Granularity(1L), + TimeSource(2L), + TrustedTimeSource(3L), + DefaultNTP(4L), + TimeZone(5L), + DSTOffset(6L), + LocalTime(7L), + TimeZoneDatabase(8L), + NTPServerAvailable(9L), + TimeZoneListMaxSize(10L), + DSTOffsetListMaxSize(11L), + SupportsDNSResolve(12L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + DSTTableEmpty(0L), + DSTStatus(1L), + TimeZoneStatus(2L), + TimeFailure(3L), + MissingTrustedTimeSource(4L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SetUTCTime(0L), + SetTrustedTimeSource(1L), + SetTimeZone(2L), + SetDSTOffset(4L), + SetDefaultNTP(5L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SetUTCTimeCommandField {UTCTime(0),Granularity(1),TimeSource(2),; + private final int id; + SetUTCTimeCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetUTCTimeCommandField value(int id) throws NoSuchFieldError { + for (SetUTCTimeCommandField field : SetUTCTimeCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetTrustedTimeSourceCommandField {TrustedTimeSource(0),; + private final int id; + SetTrustedTimeSourceCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetTrustedTimeSourceCommandField value(int id) throws NoSuchFieldError { + for (SetTrustedTimeSourceCommandField field : SetTrustedTimeSourceCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetTimeZoneCommandField {TimeZone(0),; + private final int id; + SetTimeZoneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetTimeZoneCommandField value(int id) throws NoSuchFieldError { + for (SetTimeZoneCommandField field : SetTimeZoneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetDSTOffsetCommandField {DSTOffset(0),; + private final int id; + SetDSTOffsetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetDSTOffsetCommandField value(int id) throws NoSuchFieldError { + for (SetDSTOffsetCommandField field : SetDSTOffsetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetDefaultNTPCommandField {DefaultNTP(0),; + private final int id; + SetDefaultNTPCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetDefaultNTPCommandField value(int id) throws NoSuchFieldError { + for (SetDefaultNTPCommandField field : SetDefaultNTPCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BridgedDeviceBasicInformation implements BaseCluster { + public static final long ID = 57L; + public long getID() { + return ID; + } + + public enum Attribute { + VendorName(1L), + VendorID(2L), + ProductName(3L), + NodeLabel(5L), + HardwareVersion(7L), + HardwareVersionString(8L), + SoftwareVersion(9L), + SoftwareVersionString(10L), + ManufacturingDate(11L), + PartNumber(12L), + ProductURL(13L), + ProductLabel(14L), + SerialNumber(15L), + Reachable(17L), + UniqueID(18L), + ProductAppearance(20L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StartUp(0L), + ShutDown(1L), + Leave(2L), + ReachableChanged(3L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Switch implements BaseCluster { + public static final long ID = 59L; + public long getID() { + return ID; + } + + public enum Attribute { + NumberOfPositions(0L), + CurrentPosition(1L), + MultiPressMax(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SwitchLatched(0L), + InitialPress(1L), + LongPress(2L), + ShortRelease(3L), + LongRelease(4L), + MultiPressOngoing(5L), + MultiPressComplete(6L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class AdministratorCommissioning implements BaseCluster { + public static final long ID = 60L; + public long getID() { + return ID; + } + + public enum Attribute { + WindowStatus(0L), + AdminFabricIndex(1L), + AdminVendorId(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + OpenCommissioningWindow(0L), + OpenBasicCommissioningWindow(1L), + RevokeCommissioning(2L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum OpenCommissioningWindowCommandField {CommissioningTimeout(0),PAKEPasscodeVerifier(1),Discriminator(2),Iterations(3),Salt(4),; + private final int id; + OpenCommissioningWindowCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static OpenCommissioningWindowCommandField value(int id) throws NoSuchFieldError { + for (OpenCommissioningWindowCommandField field : OpenCommissioningWindowCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum OpenBasicCommissioningWindowCommandField {CommissioningTimeout(0),; + private final int id; + OpenBasicCommissioningWindowCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static OpenBasicCommissioningWindowCommandField value(int id) throws NoSuchFieldError { + for (OpenBasicCommissioningWindowCommandField field : OpenBasicCommissioningWindowCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OperationalCredentials implements BaseCluster { + public static final long ID = 62L; + public long getID() { + return ID; + } + + public enum Attribute { + NOCs(0L), + Fabrics(1L), + SupportedFabrics(2L), + CommissionedFabrics(3L), + TrustedRootCertificates(4L), + CurrentFabricIndex(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + AttestationRequest(0L), + CertificateChainRequest(2L), + CSRRequest(4L), + AddNOC(6L), + UpdateNOC(7L), + UpdateFabricLabel(9L), + RemoveFabric(10L), + AddTrustedRootCertificate(11L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum AttestationRequestCommandField {AttestationNonce(0),; + private final int id; + AttestationRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AttestationRequestCommandField value(int id) throws NoSuchFieldError { + for (AttestationRequestCommandField field : AttestationRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum CertificateChainRequestCommandField {CertificateType(0),; + private final int id; + CertificateChainRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static CertificateChainRequestCommandField value(int id) throws NoSuchFieldError { + for (CertificateChainRequestCommandField field : CertificateChainRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum CSRRequestCommandField {CSRNonce(0),IsForUpdateNOC(1),; + private final int id; + CSRRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static CSRRequestCommandField value(int id) throws NoSuchFieldError { + for (CSRRequestCommandField field : CSRRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum AddNOCCommandField {NOCValue(0),ICACValue(1),IPKValue(2),CaseAdminSubject(3),AdminVendorId(4),; + private final int id; + AddNOCCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddNOCCommandField value(int id) throws NoSuchFieldError { + for (AddNOCCommandField field : AddNOCCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum UpdateNOCCommandField {NOCValue(0),ICACValue(1),; + private final int id; + UpdateNOCCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static UpdateNOCCommandField value(int id) throws NoSuchFieldError { + for (UpdateNOCCommandField field : UpdateNOCCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum UpdateFabricLabelCommandField {Label(0),; + private final int id; + UpdateFabricLabelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static UpdateFabricLabelCommandField value(int id) throws NoSuchFieldError { + for (UpdateFabricLabelCommandField field : UpdateFabricLabelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RemoveFabricCommandField {FabricIndex(0),; + private final int id; + RemoveFabricCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RemoveFabricCommandField value(int id) throws NoSuchFieldError { + for (RemoveFabricCommandField field : RemoveFabricCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum AddTrustedRootCertificateCommandField {RootCACertificate(0),; + private final int id; + AddTrustedRootCertificateCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static AddTrustedRootCertificateCommandField value(int id) throws NoSuchFieldError { + for (AddTrustedRootCertificateCommandField field : AddTrustedRootCertificateCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class GroupKeyManagement implements BaseCluster { + public static final long ID = 63L; + public long getID() { + return ID; + } + + public enum Attribute { + GroupKeyMap(0L), + GroupTable(1L), + MaxGroupsPerFabric(2L), + MaxGroupKeysPerFabric(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + KeySetWrite(0L), + KeySetRead(1L), + KeySetRemove(3L), + KeySetReadAllIndices(4L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum KeySetWriteCommandField {GroupKeySet(0),; + private final int id; + KeySetWriteCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static KeySetWriteCommandField value(int id) throws NoSuchFieldError { + for (KeySetWriteCommandField field : KeySetWriteCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum KeySetReadCommandField {GroupKeySetID(0),; + private final int id; + KeySetReadCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static KeySetReadCommandField value(int id) throws NoSuchFieldError { + for (KeySetReadCommandField field : KeySetReadCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum KeySetRemoveCommandField {GroupKeySetID(0),; + private final int id; + KeySetRemoveCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static KeySetRemoveCommandField value(int id) throws NoSuchFieldError { + for (KeySetRemoveCommandField field : KeySetRemoveCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum KeySetReadAllIndicesCommandField {GroupKeySetIDs(0),; + private final int id; + KeySetReadAllIndicesCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static KeySetReadAllIndicesCommandField value(int id) throws NoSuchFieldError { + for (KeySetReadAllIndicesCommandField field : KeySetReadAllIndicesCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FixedLabel implements BaseCluster { + public static final long ID = 64L; + public long getID() { + return ID; + } + + public enum Attribute { + LabelList(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class UserLabel implements BaseCluster { + public static final long ID = 65L; + public long getID() { + return ID; + } + + public enum Attribute { + LabelList(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ProxyConfiguration implements BaseCluster { + public static final long ID = 66L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ProxyDiscovery implements BaseCluster { + public static final long ID = 67L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ProxyValid implements BaseCluster { + public static final long ID = 68L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BooleanState implements BaseCluster { + public static final long ID = 69L; + public long getID() { + return ID; + } + + public enum Attribute { + StateValue(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StateChange(0L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class IcdManagement implements BaseCluster { + public static final long ID = 70L; + public long getID() { + return ID; + } + + public enum Attribute { + IdleModeInterval(0L), + ActiveModeInterval(1L), + ActiveModeThreshold(2L), + RegisteredClients(3L), + ICDCounter(4L), + ClientsSupportedPerFabric(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + RegisterClient(0L), + UnregisterClient(2L), + StayActiveRequest(3L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum RegisterClientCommandField {CheckInNodeID(0),MonitoredSubject(1),Key(2),VerificationKey(3),; + private final int id; + RegisterClientCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RegisterClientCommandField value(int id) throws NoSuchFieldError { + for (RegisterClientCommandField field : RegisterClientCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum UnregisterClientCommandField {CheckInNodeID(0),Key(1),; + private final int id; + UnregisterClientCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static UnregisterClientCommandField value(int id) throws NoSuchFieldError { + for (UnregisterClientCommandField field : UnregisterClientCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ModeSelect implements BaseCluster { + public static final long ID = 80L; + public long getID() { + return ID; + } + + public enum Attribute { + Description(0L), + StandardNamespace(1L), + SupportedModes(2L), + CurrentMode(3L), + StartUpMode(4L), + OnMode(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ChangeToMode(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum ChangeToModeCommandField {NewMode(0),; + private final int id; + ChangeToModeCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ChangeToModeCommandField value(int id) throws NoSuchFieldError { + for (ChangeToModeCommandField field : ChangeToModeCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TemperatureControl implements BaseCluster { + public static final long ID = 86L; + public long getID() { + return ID; + } + + public enum Attribute { + TemperatureSetpoint(0L), + MinTemperature(1L), + MaxTemperature(2L), + Step(3L), + CurrentTemperatureLevelIndex(4L), + SupportedTemperatureLevels(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SetTemperature(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SetTemperatureCommandField {TargetTemperature(0),TargetTemperatureLevel(1),; + private final int id; + SetTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetTemperatureCommandField value(int id) throws NoSuchFieldError { + for (SetTemperatureCommandField field : SetTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class RefrigeratorAlarm implements BaseCluster { + public static final long ID = 87L; + public long getID() { + return ID; + } + + public enum Attribute { + Mask(0L), + Latch(1L), + State(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Notify(0L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Reset(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum ResetCommandField {Alarms(0),Mask(1),; + private final int id; + ResetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ResetCommandField value(int id) throws NoSuchFieldError { + for (ResetCommandField field : ResetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class AirQuality implements BaseCluster { + public static final long ID = 91L; + public long getID() { + return ID; + } + + public enum Attribute { + AirQuality(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class SmokeCoAlarm implements BaseCluster { + public static final long ID = 92L; + public long getID() { + return ID; + } + + public enum Attribute { + ExpressedState(0L), + SmokeState(1L), + COState(2L), + BatteryAlert(3L), + DeviceMuted(4L), + TestInProgress(5L), + HardwareFaultAlert(6L), + EndOfServiceAlert(7L), + InterconnectSmokeAlarm(8L), + InterconnectCOAlarm(9L), + ContaminationState(10L), + SensitivityLevel(11L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SmokeAlarm(0L), + COAlarm(1L), + LowBattery(2L), + HardwareFault(3L), + EndOfService(4L), + SelfTestComplete(5L), + AlarmMuted(6L), + MuteEnded(7L), + InterconnectSmokeAlarm(8L), + InterconnectCOAlarm(9L), + AllClear(10L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SelfTestRequest(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class DishwasherAlarm implements BaseCluster { + public static final long ID = 93L; + public long getID() { + return ID; + } + + public enum Attribute { + Mask(0L), + Latch(1L), + State(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Notify(0L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Reset(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum ResetCommandField {Alarms(0),Mask(1),; + private final int id; + ResetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ResetCommandField value(int id) throws NoSuchFieldError { + for (ResetCommandField field : ResetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class HepaFilterMonitoring implements BaseCluster { + public static final long ID = 113L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ActivatedCarbonFilterMonitoring implements BaseCluster { + public static final long ID = 114L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class CeramicFilterMonitoring implements BaseCluster { + public static final long ID = 115L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ElectrostaticFilterMonitoring implements BaseCluster { + public static final long ID = 116L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class UvFilterMonitoring implements BaseCluster { + public static final long ID = 117L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class IonizingFilterMonitoring implements BaseCluster { + public static final long ID = 118L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ZeoliteFilterMonitoring implements BaseCluster { + public static final long ID = 119L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OzoneFilterMonitoring implements BaseCluster { + public static final long ID = 120L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class WaterTankMonitoring implements BaseCluster { + public static final long ID = 121L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FuelTankMonitoring implements BaseCluster { + public static final long ID = 122L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class InkCartridgeMonitoring implements BaseCluster { + public static final long ID = 123L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TonerCartridgeMonitoring implements BaseCluster { + public static final long ID = 124L; + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class DoorLock implements BaseCluster { + public static final long ID = 257L; + public long getID() { + return ID; + } + + public enum Attribute { + LockState(0L), + LockType(1L), + ActuatorEnabled(2L), + DoorState(3L), + DoorOpenEvents(4L), + DoorClosedEvents(5L), + OpenPeriod(6L), + NumberOfTotalUsersSupported(17L), + NumberOfPINUsersSupported(18L), + NumberOfRFIDUsersSupported(19L), + NumberOfWeekDaySchedulesSupportedPerUser(20L), + NumberOfYearDaySchedulesSupportedPerUser(21L), + NumberOfHolidaySchedulesSupported(22L), + MaxPINCodeLength(23L), + MinPINCodeLength(24L), + MaxRFIDCodeLength(25L), + MinRFIDCodeLength(26L), + CredentialRulesSupport(27L), + NumberOfCredentialsSupportedPerUser(28L), + Language(33L), + LEDSettings(34L), + AutoRelockTime(35L), + SoundVolume(36L), + OperatingMode(37L), + SupportedOperatingModes(38L), + DefaultConfigurationRegister(39L), + EnableLocalProgramming(40L), + EnableOneTouchLocking(41L), + EnableInsideStatusLED(42L), + EnablePrivacyModeButton(43L), + LocalProgrammingFeatures(44L), + WrongCodeEntryLimit(48L), + UserCodeTemporaryDisableTime(49L), + SendPINOverTheAir(50L), + RequirePINforRemoteOperation(51L), + ExpiringUserTimeout(53L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + DoorLockAlarm(0L), + DoorStateChange(1L), + LockOperation(2L), + LockOperationError(3L), + LockUserChange(4L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + LockDoor(0L), + UnlockDoor(1L), + UnlockWithTimeout(3L), + SetWeekDaySchedule(11L), + GetWeekDaySchedule(12L), + ClearWeekDaySchedule(13L), + SetYearDaySchedule(14L), + GetYearDaySchedule(15L), + ClearYearDaySchedule(16L), + SetHolidaySchedule(17L), + GetHolidaySchedule(18L), + ClearHolidaySchedule(19L), + SetUser(26L), + GetUser(27L), + ClearUser(29L), + SetCredential(34L), + GetCredentialStatus(36L), + ClearCredential(38L), + UnboltDoor(39L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum LockDoorCommandField {PINCode(0),; + private final int id; + LockDoorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static LockDoorCommandField value(int id) throws NoSuchFieldError { + for (LockDoorCommandField field : LockDoorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum UnlockDoorCommandField {PINCode(0),; + private final int id; + UnlockDoorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static UnlockDoorCommandField value(int id) throws NoSuchFieldError { + for (UnlockDoorCommandField field : UnlockDoorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum UnlockWithTimeoutCommandField {Timeout(0),PINCode(1),; + private final int id; + UnlockWithTimeoutCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static UnlockWithTimeoutCommandField value(int id) throws NoSuchFieldError { + for (UnlockWithTimeoutCommandField field : UnlockWithTimeoutCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetWeekDayScheduleCommandField {WeekDayIndex(0),UserIndex(1),DaysMask(2),StartHour(3),StartMinute(4),EndHour(5),EndMinute(6),; + private final int id; + SetWeekDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetWeekDayScheduleCommandField field : SetWeekDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetWeekDayScheduleCommandField {WeekDayIndex(0),UserIndex(1),; + private final int id; + GetWeekDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetWeekDayScheduleCommandField field : GetWeekDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ClearWeekDayScheduleCommandField {WeekDayIndex(0),UserIndex(1),; + private final int id; + ClearWeekDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ClearWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (ClearWeekDayScheduleCommandField field : ClearWeekDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetYearDayScheduleCommandField {YearDayIndex(0),UserIndex(1),LocalStartTime(2),LocalEndTime(3),; + private final int id; + SetYearDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetYearDayScheduleCommandField field : SetYearDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetYearDayScheduleCommandField {YearDayIndex(0),UserIndex(1),; + private final int id; + GetYearDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetYearDayScheduleCommandField field : GetYearDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ClearYearDayScheduleCommandField {YearDayIndex(0),UserIndex(1),; + private final int id; + ClearYearDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ClearYearDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (ClearYearDayScheduleCommandField field : ClearYearDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetHolidayScheduleCommandField {HolidayIndex(0),LocalStartTime(1),LocalEndTime(2),OperatingMode(3),; + private final int id; + SetHolidayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetHolidayScheduleCommandField field : SetHolidayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetHolidayScheduleCommandField {HolidayIndex(0),; + private final int id; + GetHolidayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetHolidayScheduleCommandField field : GetHolidayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ClearHolidayScheduleCommandField {HolidayIndex(0),; + private final int id; + ClearHolidayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ClearHolidayScheduleCommandField value(int id) throws NoSuchFieldError { + for (ClearHolidayScheduleCommandField field : ClearHolidayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetUserCommandField {OperationType(0),UserIndex(1),UserName(2),UserUniqueID(3),UserStatus(4),UserType(5),CredentialRule(6),; + private final int id; + SetUserCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetUserCommandField value(int id) throws NoSuchFieldError { + for (SetUserCommandField field : SetUserCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetUserCommandField {UserIndex(0),; + private final int id; + GetUserCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetUserCommandField value(int id) throws NoSuchFieldError { + for (GetUserCommandField field : GetUserCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ClearUserCommandField {UserIndex(0),; + private final int id; + ClearUserCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ClearUserCommandField value(int id) throws NoSuchFieldError { + for (ClearUserCommandField field : ClearUserCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetCredentialCommandField {OperationType(0),Credential(1),CredentialData(2),UserIndex(3),UserStatus(4),UserType(5),; + private final int id; + SetCredentialCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetCredentialCommandField value(int id) throws NoSuchFieldError { + for (SetCredentialCommandField field : SetCredentialCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetCredentialStatusCommandField {Credential(0),; + private final int id; + GetCredentialStatusCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetCredentialStatusCommandField value(int id) throws NoSuchFieldError { + for (GetCredentialStatusCommandField field : GetCredentialStatusCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ClearCredentialCommandField {Credential(0),; + private final int id; + ClearCredentialCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ClearCredentialCommandField value(int id) throws NoSuchFieldError { + for (ClearCredentialCommandField field : ClearCredentialCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum UnboltDoorCommandField {PINCode(0),; + private final int id; + UnboltDoorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static UnboltDoorCommandField value(int id) throws NoSuchFieldError { + for (UnboltDoorCommandField field : UnboltDoorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class WindowCovering implements BaseCluster { + public static final long ID = 258L; + public long getID() { + return ID; + } + + public enum Attribute { + Type(0L), + PhysicalClosedLimitLift(1L), + PhysicalClosedLimitTilt(2L), + CurrentPositionLift(3L), + CurrentPositionTilt(4L), + NumberOfActuationsLift(5L), + NumberOfActuationsTilt(6L), + ConfigStatus(7L), + CurrentPositionLiftPercentage(8L), + CurrentPositionTiltPercentage(9L), + OperationalStatus(10L), + TargetPositionLiftPercent100ths(11L), + TargetPositionTiltPercent100ths(12L), + EndProductType(13L), + CurrentPositionLiftPercent100ths(14L), + CurrentPositionTiltPercent100ths(15L), + InstalledOpenLimitLift(16L), + InstalledClosedLimitLift(17L), + InstalledOpenLimitTilt(18L), + InstalledClosedLimitTilt(19L), + Mode(23L), + SafetyStatus(26L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + UpOrOpen(0L), + DownOrClose(1L), + StopMotion(2L), + GoToLiftValue(4L), + GoToLiftPercentage(5L), + GoToTiltValue(7L), + GoToTiltPercentage(8L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum GoToLiftValueCommandField {LiftValue(0),; + private final int id; + GoToLiftValueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GoToLiftValueCommandField value(int id) throws NoSuchFieldError { + for (GoToLiftValueCommandField field : GoToLiftValueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GoToLiftPercentageCommandField {LiftPercent100thsValue(0),; + private final int id; + GoToLiftPercentageCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GoToLiftPercentageCommandField value(int id) throws NoSuchFieldError { + for (GoToLiftPercentageCommandField field : GoToLiftPercentageCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GoToTiltValueCommandField {TiltValue(0),; + private final int id; + GoToTiltValueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GoToTiltValueCommandField value(int id) throws NoSuchFieldError { + for (GoToTiltValueCommandField field : GoToTiltValueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GoToTiltPercentageCommandField {TiltPercent100thsValue(0),; + private final int id; + GoToTiltPercentageCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GoToTiltPercentageCommandField value(int id) throws NoSuchFieldError { + for (GoToTiltPercentageCommandField field : GoToTiltPercentageCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BarrierControl implements BaseCluster { + public static final long ID = 259L; + public long getID() { + return ID; + } + + public enum Attribute { + BarrierMovingState(1L), + BarrierSafetyStatus(2L), + BarrierCapabilities(3L), + BarrierOpenEvents(4L), + BarrierCloseEvents(5L), + BarrierCommandOpenEvents(6L), + BarrierCommandCloseEvents(7L), + BarrierOpenPeriod(8L), + BarrierClosePeriod(9L), + BarrierPosition(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + BarrierControlGoToPercent(0L), + BarrierControlStop(1L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum BarrierControlGoToPercentCommandField {PercentOpen(0),; + private final int id; + BarrierControlGoToPercentCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static BarrierControlGoToPercentCommandField value(int id) throws NoSuchFieldError { + for (BarrierControlGoToPercentCommandField field : BarrierControlGoToPercentCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class PumpConfigurationAndControl implements BaseCluster { + public static final long ID = 512L; + public long getID() { + return ID; + } + + public enum Attribute { + MaxPressure(0L), + MaxSpeed(1L), + MaxFlow(2L), + MinConstPressure(3L), + MaxConstPressure(4L), + MinCompPressure(5L), + MaxCompPressure(6L), + MinConstSpeed(7L), + MaxConstSpeed(8L), + MinConstFlow(9L), + MaxConstFlow(10L), + MinConstTemp(11L), + MaxConstTemp(12L), + PumpStatus(16L), + EffectiveOperationMode(17L), + EffectiveControlMode(18L), + Capacity(19L), + Speed(20L), + LifetimeRunningHours(21L), + Power(22L), + LifetimeEnergyConsumed(23L), + OperationMode(32L), + ControlMode(33L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SupplyVoltageLow(0L), + SupplyVoltageHigh(1L), + PowerMissingPhase(2L), + SystemPressureLow(3L), + SystemPressureHigh(4L), + DryRunning(5L), + MotorTemperatureHigh(6L), + PumpMotorFatalFailure(7L), + ElectronicTemperatureHigh(8L), + PumpBlocked(9L), + SensorFailure(10L), + ElectronicNonFatalFailure(11L), + ElectronicFatalFailure(12L), + GeneralFault(13L), + Leakage(14L), + AirDetection(15L), + TurbineOperation(16L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Thermostat implements BaseCluster { + public static final long ID = 513L; + public long getID() { + return ID; + } + + public enum Attribute { + LocalTemperature(0L), + OutdoorTemperature(1L), + Occupancy(2L), + AbsMinHeatSetpointLimit(3L), + AbsMaxHeatSetpointLimit(4L), + AbsMinCoolSetpointLimit(5L), + AbsMaxCoolSetpointLimit(6L), + PICoolingDemand(7L), + PIHeatingDemand(8L), + HVACSystemTypeConfiguration(9L), + LocalTemperatureCalibration(16L), + OccupiedCoolingSetpoint(17L), + OccupiedHeatingSetpoint(18L), + UnoccupiedCoolingSetpoint(19L), + UnoccupiedHeatingSetpoint(20L), + MinHeatSetpointLimit(21L), + MaxHeatSetpointLimit(22L), + MinCoolSetpointLimit(23L), + MaxCoolSetpointLimit(24L), + MinSetpointDeadBand(25L), + RemoteSensing(26L), + ControlSequenceOfOperation(27L), + SystemMode(28L), + ThermostatRunningMode(30L), + StartOfWeek(32L), + NumberOfWeeklyTransitions(33L), + NumberOfDailyTransitions(34L), + TemperatureSetpointHold(35L), + TemperatureSetpointHoldDuration(36L), + ThermostatProgrammingOperationMode(37L), + ThermostatRunningState(41L), + SetpointChangeSource(48L), + SetpointChangeAmount(49L), + SetpointChangeSourceTimestamp(50L), + OccupiedSetback(52L), + OccupiedSetbackMin(53L), + OccupiedSetbackMax(54L), + UnoccupiedSetback(55L), + UnoccupiedSetbackMin(56L), + UnoccupiedSetbackMax(57L), + EmergencyHeatDelta(58L), + ACType(64L), + ACCapacity(65L), + ACRefrigerantType(66L), + ACCompressorType(67L), + ACErrorCode(68L), + ACLouverPosition(69L), + ACCoilTemperature(70L), + ACCapacityformat(71L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SetpointRaiseLower(0L), + SetWeeklySchedule(1L), + GetWeeklySchedule(2L), + ClearWeeklySchedule(3L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SetpointRaiseLowerCommandField {Mode(0),Amount(1),; + private final int id; + SetpointRaiseLowerCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetpointRaiseLowerCommandField value(int id) throws NoSuchFieldError { + for (SetpointRaiseLowerCommandField field : SetpointRaiseLowerCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SetWeeklyScheduleCommandField {NumberOfTransitionsForSequence(0),DayOfWeekForSequence(1),ModeForSequence(2),Transitions(3),; + private final int id; + SetWeeklyScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetWeeklyScheduleCommandField field : SetWeeklyScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum GetWeeklyScheduleCommandField {DaysToReturn(0),ModeToReturn(1),; + private final int id; + GetWeeklyScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetWeeklyScheduleCommandField field : GetWeeklyScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FanControl implements BaseCluster { + public static final long ID = 514L; + public long getID() { + return ID; + } + + public enum Attribute { + FanMode(0L), + FanModeSequence(1L), + PercentSetting(2L), + PercentCurrent(3L), + SpeedMax(4L), + SpeedSetting(5L), + SpeedCurrent(6L), + RockSupport(7L), + RockSetting(8L), + WindSupport(9L), + WindSetting(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ThermostatUserInterfaceConfiguration implements BaseCluster { + public static final long ID = 516L; + public long getID() { + return ID; + } + + public enum Attribute { + TemperatureDisplayMode(0L), + KeypadLockout(1L), + ScheduleProgrammingVisibility(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ColorControl implements BaseCluster { + public static final long ID = 768L; + public long getID() { + return ID; + } + + public enum Attribute { + CurrentHue(0L), + CurrentSaturation(1L), + RemainingTime(2L), + CurrentX(3L), + CurrentY(4L), + DriftCompensation(5L), + CompensationText(6L), + ColorTemperatureMireds(7L), + ColorMode(8L), + Options(15L), + NumberOfPrimaries(16L), + Primary1X(17L), + Primary1Y(18L), + Primary1Intensity(19L), + Primary2X(21L), + Primary2Y(22L), + Primary2Intensity(23L), + Primary3X(25L), + Primary3Y(26L), + Primary3Intensity(27L), + Primary4X(32L), + Primary4Y(33L), + Primary4Intensity(34L), + Primary5X(36L), + Primary5Y(37L), + Primary5Intensity(38L), + Primary6X(40L), + Primary6Y(41L), + Primary6Intensity(42L), + WhitePointX(48L), + WhitePointY(49L), + ColorPointRX(50L), + ColorPointRY(51L), + ColorPointRIntensity(52L), + ColorPointGX(54L), + ColorPointGY(55L), + ColorPointGIntensity(56L), + ColorPointBX(58L), + ColorPointBY(59L), + ColorPointBIntensity(60L), + EnhancedCurrentHue(16384L), + EnhancedColorMode(16385L), + ColorLoopActive(16386L), + ColorLoopDirection(16387L), + ColorLoopTime(16388L), + ColorLoopStartEnhancedHue(16389L), + ColorLoopStoredEnhancedHue(16390L), + ColorCapabilities(16394L), + ColorTempPhysicalMinMireds(16395L), + ColorTempPhysicalMaxMireds(16396L), + CoupleColorTempToLevelMinMireds(16397L), + StartUpColorTemperatureMireds(16400L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + MoveToHue(0L), + MoveHue(1L), + StepHue(2L), + MoveToSaturation(3L), + MoveSaturation(4L), + StepSaturation(5L), + MoveToHueAndSaturation(6L), + MoveToColor(7L), + MoveColor(8L), + StepColor(9L), + MoveToColorTemperature(10L), + EnhancedMoveToHue(64L), + EnhancedMoveHue(65L), + EnhancedStepHue(66L), + EnhancedMoveToHueAndSaturation(67L), + ColorLoopSet(68L), + StopMoveStep(71L), + MoveColorTemperature(75L), + StepColorTemperature(76L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToHueCommandField {Hue(0),Direction(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + MoveToHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToHueCommandField value(int id) throws NoSuchFieldError { + for (MoveToHueCommandField field : MoveToHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveHueCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveHueCommandField value(int id) throws NoSuchFieldError { + for (MoveHueCommandField field : MoveHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StepHueCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + StepHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StepHueCommandField value(int id) throws NoSuchFieldError { + for (StepHueCommandField field : StepHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToSaturationCommandField {Saturation(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveToSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToSaturationCommandField value(int id) throws NoSuchFieldError { + for (MoveToSaturationCommandField field : MoveToSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveSaturationCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveSaturationCommandField value(int id) throws NoSuchFieldError { + for (MoveSaturationCommandField field : MoveSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StepSaturationCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + StepSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StepSaturationCommandField value(int id) throws NoSuchFieldError { + for (StepSaturationCommandField field : StepSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToHueAndSaturationCommandField {Hue(0),Saturation(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + MoveToHueAndSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToHueAndSaturationCommandField value(int id) throws NoSuchFieldError { + for (MoveToHueAndSaturationCommandField field : MoveToHueAndSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToColorCommandField {ColorX(0),ColorY(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + MoveToColorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToColorCommandField value(int id) throws NoSuchFieldError { + for (MoveToColorCommandField field : MoveToColorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveColorCommandField {RateX(0),RateY(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveColorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveColorCommandField value(int id) throws NoSuchFieldError { + for (MoveColorCommandField field : MoveColorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StepColorCommandField {StepX(0),StepY(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + StepColorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StepColorCommandField value(int id) throws NoSuchFieldError { + for (StepColorCommandField field : StepColorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveToColorTemperatureCommandField {ColorTemperatureMireds(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + MoveToColorTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveToColorTemperatureCommandField value(int id) throws NoSuchFieldError { + for (MoveToColorTemperatureCommandField field : MoveToColorTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnhancedMoveToHueCommandField {EnhancedHue(0),Direction(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + EnhancedMoveToHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnhancedMoveToHueCommandField value(int id) throws NoSuchFieldError { + for (EnhancedMoveToHueCommandField field : EnhancedMoveToHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnhancedMoveHueCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; + private final int id; + EnhancedMoveHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnhancedMoveHueCommandField value(int id) throws NoSuchFieldError { + for (EnhancedMoveHueCommandField field : EnhancedMoveHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnhancedStepHueCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + EnhancedStepHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnhancedStepHueCommandField value(int id) throws NoSuchFieldError { + for (EnhancedStepHueCommandField field : EnhancedStepHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum EnhancedMoveToHueAndSaturationCommandField {EnhancedHue(0),Saturation(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; + private final int id; + EnhancedMoveToHueAndSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static EnhancedMoveToHueAndSaturationCommandField value(int id) throws NoSuchFieldError { + for (EnhancedMoveToHueAndSaturationCommandField field : EnhancedMoveToHueAndSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ColorLoopSetCommandField {UpdateFlags(0),Action(1),Direction(2),Time(3),StartHue(4),OptionsMask(5),OptionsOverride(6),; + private final int id; + ColorLoopSetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ColorLoopSetCommandField value(int id) throws NoSuchFieldError { + for (ColorLoopSetCommandField field : ColorLoopSetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StopMoveStepCommandField {OptionsMask(0),OptionsOverride(1),; + private final int id; + StopMoveStepCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StopMoveStepCommandField value(int id) throws NoSuchFieldError { + for (StopMoveStepCommandField field : StopMoveStepCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum MoveColorTemperatureCommandField {MoveMode(0),Rate(1),ColorTemperatureMinimumMireds(2),ColorTemperatureMaximumMireds(3),OptionsMask(4),OptionsOverride(5),; + private final int id; + MoveColorTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static MoveColorTemperatureCommandField value(int id) throws NoSuchFieldError { + for (MoveColorTemperatureCommandField field : MoveColorTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StepColorTemperatureCommandField {StepMode(0),StepSize(1),TransitionTime(2),ColorTemperatureMinimumMireds(3),ColorTemperatureMaximumMireds(4),OptionsMask(5),OptionsOverride(6),; + private final int id; + StepColorTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StepColorTemperatureCommandField value(int id) throws NoSuchFieldError { + for (StepColorTemperatureCommandField field : StepColorTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class BallastConfiguration implements BaseCluster { + public static final long ID = 769L; + public long getID() { + return ID; + } + + public enum Attribute { + PhysicalMinLevel(0L), + PhysicalMaxLevel(1L), + BallastStatus(2L), + MinLevel(16L), + MaxLevel(17L), + IntrinsicBallastFactor(20L), + BallastFactorAdjustment(21L), + LampQuantity(32L), + LampType(48L), + LampManufacturer(49L), + LampRatedHours(50L), + LampBurnHours(51L), + LampAlarmMode(52L), + LampBurnHoursTripPoint(53L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class IlluminanceMeasurement implements BaseCluster { + public static final long ID = 1024L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + LightSensorType(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TemperatureMeasurement implements BaseCluster { + public static final long ID = 1026L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class PressureMeasurement implements BaseCluster { + public static final long ID = 1027L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + ScaledValue(16L), + MinScaledValue(17L), + MaxScaledValue(18L), + ScaledTolerance(19L), + Scale(20L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FlowMeasurement implements BaseCluster { + public static final long ID = 1028L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class RelativeHumidityMeasurement implements BaseCluster { + public static final long ID = 1029L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class OccupancySensing implements BaseCluster { + public static final long ID = 1030L; + public long getID() { + return ID; + } + + public enum Attribute { + Occupancy(0L), + OccupancySensorType(1L), + OccupancySensorTypeBitmap(2L), + PIROccupiedToUnoccupiedDelay(16L), + PIRUnoccupiedToOccupiedDelay(17L), + PIRUnoccupiedToOccupiedThreshold(18L), + UltrasonicOccupiedToUnoccupiedDelay(32L), + UltrasonicUnoccupiedToOccupiedDelay(33L), + UltrasonicUnoccupiedToOccupiedThreshold(34L), + PhysicalContactOccupiedToUnoccupiedDelay(48L), + PhysicalContactUnoccupiedToOccupiedDelay(49L), + PhysicalContactUnoccupiedToOccupiedThreshold(50L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class WakeOnLan implements BaseCluster { + public static final long ID = 1283L; + public long getID() { + return ID; + } + + public enum Attribute { + MACAddress(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class Channel implements BaseCluster { + public static final long ID = 1284L; + public long getID() { + return ID; + } + + public enum Attribute { + ChannelList(0L), + Lineup(1L), + CurrentChannel(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ChangeChannel(0L), + ChangeChannelByNumber(2L), + SkipChannel(3L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum ChangeChannelCommandField {Match(0),; + private final int id; + ChangeChannelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ChangeChannelCommandField value(int id) throws NoSuchFieldError { + for (ChangeChannelCommandField field : ChangeChannelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum ChangeChannelByNumberCommandField {MajorNumber(0),MinorNumber(1),; + private final int id; + ChangeChannelByNumberCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static ChangeChannelByNumberCommandField value(int id) throws NoSuchFieldError { + for (ChangeChannelByNumberCommandField field : ChangeChannelByNumberCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SkipChannelCommandField {Count(0),; + private final int id; + SkipChannelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SkipChannelCommandField value(int id) throws NoSuchFieldError { + for (SkipChannelCommandField field : SkipChannelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class TargetNavigator implements BaseCluster { + public static final long ID = 1285L; + public long getID() { + return ID; + } + + public enum Attribute { + TargetList(0L), + CurrentTarget(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + NavigateTarget(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum NavigateTargetCommandField {Target(0),Data(1),; + private final int id; + NavigateTargetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static NavigateTargetCommandField value(int id) throws NoSuchFieldError { + for (NavigateTargetCommandField field : NavigateTargetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class MediaPlayback implements BaseCluster { + public static final long ID = 1286L; + public long getID() { + return ID; + } + + public enum Attribute { + CurrentState(0L), + StartTime(1L), + Duration(2L), + SampledPosition(3L), + PlaybackSpeed(4L), + SeekRangeEnd(5L), + SeekRangeStart(6L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Play(0L), + Pause(1L), + Stop(2L), + StartOver(3L), + Previous(4L), + Next(5L), + Rewind(6L), + FastForward(7L), + SkipForward(8L), + SkipBackward(9L), + Seek(11L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SkipForwardCommandField {DeltaPositionMilliseconds(0),; + private final int id; + SkipForwardCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SkipForwardCommandField value(int id) throws NoSuchFieldError { + for (SkipForwardCommandField field : SkipForwardCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SkipBackwardCommandField {DeltaPositionMilliseconds(0),; + private final int id; + SkipBackwardCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SkipBackwardCommandField value(int id) throws NoSuchFieldError { + for (SkipBackwardCommandField field : SkipBackwardCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SeekCommandField {Position(0),; + private final int id; + SeekCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SeekCommandField value(int id) throws NoSuchFieldError { + for (SeekCommandField field : SeekCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class MediaInput implements BaseCluster { + public static final long ID = 1287L; + public long getID() { + return ID; + } + + public enum Attribute { + InputList(0L), + CurrentInput(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SelectInput(0L), + ShowInputStatus(1L), + HideInputStatus(2L), + RenameInput(3L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SelectInputCommandField {Index(0),; + private final int id; + SelectInputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SelectInputCommandField value(int id) throws NoSuchFieldError { + for (SelectInputCommandField field : SelectInputCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RenameInputCommandField {Index(0),Name(1),; + private final int id; + RenameInputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RenameInputCommandField value(int id) throws NoSuchFieldError { + for (RenameInputCommandField field : RenameInputCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class LowPower implements BaseCluster { + public static final long ID = 1288L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Sleep(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class KeypadInput implements BaseCluster { + public static final long ID = 1289L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SendKey(0L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SendKeyCommandField {KeyCode(0),; + private final int id; + SendKeyCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SendKeyCommandField value(int id) throws NoSuchFieldError { + for (SendKeyCommandField field : SendKeyCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ContentLauncher implements BaseCluster { + public static final long ID = 1290L; + public long getID() { + return ID; + } + + public enum Attribute { + AcceptHeader(0L), + SupportedStreamingProtocols(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + LaunchContent(0L), + LaunchURL(1L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum LaunchContentCommandField {Search(0),AutoPlay(1),Data(2),; + private final int id; + LaunchContentCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static LaunchContentCommandField value(int id) throws NoSuchFieldError { + for (LaunchContentCommandField field : LaunchContentCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum LaunchURLCommandField {ContentURL(0),DisplayString(1),BrandingInformation(2),; + private final int id; + LaunchURLCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static LaunchURLCommandField value(int id) throws NoSuchFieldError { + for (LaunchURLCommandField field : LaunchURLCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class AudioOutput implements BaseCluster { + public static final long ID = 1291L; + public long getID() { + return ID; + } + + public enum Attribute { + OutputList(0L), + CurrentOutput(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SelectOutput(0L), + RenameOutput(1L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum SelectOutputCommandField {Index(0),; + private final int id; + SelectOutputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SelectOutputCommandField value(int id) throws NoSuchFieldError { + for (SelectOutputCommandField field : SelectOutputCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum RenameOutputCommandField {Index(0),Name(1),; + private final int id; + RenameOutputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static RenameOutputCommandField value(int id) throws NoSuchFieldError { + for (RenameOutputCommandField field : RenameOutputCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ApplicationLauncher implements BaseCluster { + public static final long ID = 1292L; + public long getID() { + return ID; + } + + public enum Attribute { + CatalogList(0L), + CurrentApp(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + LaunchApp(0L), + StopApp(1L), + HideApp(2L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum LaunchAppCommandField {Application(0),Data(1),; + private final int id; + LaunchAppCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static LaunchAppCommandField value(int id) throws NoSuchFieldError { + for (LaunchAppCommandField field : LaunchAppCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum StopAppCommandField {Application(0),; + private final int id; + StopAppCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static StopAppCommandField value(int id) throws NoSuchFieldError { + for (StopAppCommandField field : StopAppCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum HideAppCommandField {Application(0),; + private final int id; + HideAppCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static HideAppCommandField value(int id) throws NoSuchFieldError { + for (HideAppCommandField field : HideAppCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ApplicationBasic implements BaseCluster { + public static final long ID = 1293L; + public long getID() { + return ID; + } + + public enum Attribute { + VendorName(0L), + VendorID(1L), + ApplicationName(2L), + ProductID(3L), + Application(4L), + Status(5L), + ApplicationVersion(6L), + AllowedVendorList(7L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command {; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class AccountLogin implements BaseCluster { + public static final long ID = 1294L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + GetSetupPIN(0L), + Login(2L), + Logout(3L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum GetSetupPINCommandField {TempAccountIdentifier(0),; + private final int id; + GetSetupPINCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetSetupPINCommandField value(int id) throws NoSuchFieldError { + for (GetSetupPINCommandField field : GetSetupPINCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum LoginCommandField {TempAccountIdentifier(0),SetupPIN(1),; + private final int id; + LoginCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static LoginCommandField value(int id) throws NoSuchFieldError { + for (LoginCommandField field : LoginCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class ElectricalMeasurement implements BaseCluster { + public static final long ID = 2820L; + public long getID() { + return ID; + } + + public enum Attribute { + MeasurementType(0L), + DcVoltage(256L), + DcVoltageMin(257L), + DcVoltageMax(258L), + DcCurrent(259L), + DcCurrentMin(260L), + DcCurrentMax(261L), + DcPower(262L), + DcPowerMin(263L), + DcPowerMax(264L), + DcVoltageMultiplier(512L), + DcVoltageDivisor(513L), + DcCurrentMultiplier(514L), + DcCurrentDivisor(515L), + DcPowerMultiplier(516L), + DcPowerDivisor(517L), + AcFrequency(768L), + AcFrequencyMin(769L), + AcFrequencyMax(770L), + NeutralCurrent(771L), + TotalActivePower(772L), + TotalReactivePower(773L), + TotalApparentPower(774L), + Measured1stHarmonicCurrent(775L), + Measured3rdHarmonicCurrent(776L), + Measured5thHarmonicCurrent(777L), + Measured7thHarmonicCurrent(778L), + Measured9thHarmonicCurrent(779L), + Measured11thHarmonicCurrent(780L), + MeasuredPhase1stHarmonicCurrent(781L), + MeasuredPhase3rdHarmonicCurrent(782L), + MeasuredPhase5thHarmonicCurrent(783L), + MeasuredPhase7thHarmonicCurrent(784L), + MeasuredPhase9thHarmonicCurrent(785L), + MeasuredPhase11thHarmonicCurrent(786L), + AcFrequencyMultiplier(1024L), + AcFrequencyDivisor(1025L), + PowerMultiplier(1026L), + PowerDivisor(1027L), + HarmonicCurrentMultiplier(1028L), + PhaseHarmonicCurrentMultiplier(1029L), + InstantaneousVoltage(1280L), + InstantaneousLineCurrent(1281L), + InstantaneousActiveCurrent(1282L), + InstantaneousReactiveCurrent(1283L), + InstantaneousPower(1284L), + RmsVoltage(1285L), + RmsVoltageMin(1286L), + RmsVoltageMax(1287L), + RmsCurrent(1288L), + RmsCurrentMin(1289L), + RmsCurrentMax(1290L), + ActivePower(1291L), + ActivePowerMin(1292L), + ActivePowerMax(1293L), + ReactivePower(1294L), + ApparentPower(1295L), + PowerFactor(1296L), + AverageRmsVoltageMeasurementPeriod(1297L), + AverageRmsUnderVoltageCounter(1299L), + RmsExtremeOverVoltagePeriod(1300L), + RmsExtremeUnderVoltagePeriod(1301L), + RmsVoltageSagPeriod(1302L), + RmsVoltageSwellPeriod(1303L), + AcVoltageMultiplier(1536L), + AcVoltageDivisor(1537L), + AcCurrentMultiplier(1538L), + AcCurrentDivisor(1539L), + AcPowerMultiplier(1540L), + AcPowerDivisor(1541L), + OverloadAlarmsMask(1792L), + VoltageOverload(1793L), + CurrentOverload(1794L), + AcOverloadAlarmsMask(2048L), + AcVoltageOverload(2049L), + AcCurrentOverload(2050L), + AcActivePowerOverload(2051L), + AcReactivePowerOverload(2052L), + AverageRmsOverVoltage(2053L), + AverageRmsUnderVoltage(2054L), + RmsExtremeOverVoltage(2055L), + RmsExtremeUnderVoltage(2056L), + RmsVoltageSag(2057L), + RmsVoltageSwell(2058L), + LineCurrentPhaseB(2305L), + ActiveCurrentPhaseB(2306L), + ReactiveCurrentPhaseB(2307L), + RmsVoltagePhaseB(2309L), + RmsVoltageMinPhaseB(2310L), + RmsVoltageMaxPhaseB(2311L), + RmsCurrentPhaseB(2312L), + RmsCurrentMinPhaseB(2313L), + RmsCurrentMaxPhaseB(2314L), + ActivePowerPhaseB(2315L), + ActivePowerMinPhaseB(2316L), + ActivePowerMaxPhaseB(2317L), + ReactivePowerPhaseB(2318L), + ApparentPowerPhaseB(2319L), + PowerFactorPhaseB(2320L), + AverageRmsVoltageMeasurementPeriodPhaseB(2321L), + AverageRmsOverVoltageCounterPhaseB(2322L), + AverageRmsUnderVoltageCounterPhaseB(2323L), + RmsExtremeOverVoltagePeriodPhaseB(2324L), + RmsExtremeUnderVoltagePeriodPhaseB(2325L), + RmsVoltageSagPeriodPhaseB(2326L), + RmsVoltageSwellPeriodPhaseB(2327L), + LineCurrentPhaseC(2561L), + ActiveCurrentPhaseC(2562L), + ReactiveCurrentPhaseC(2563L), + RmsVoltagePhaseC(2565L), + RmsVoltageMinPhaseC(2566L), + RmsVoltageMaxPhaseC(2567L), + RmsCurrentPhaseC(2568L), + RmsCurrentMinPhaseC(2569L), + RmsCurrentMaxPhaseC(2570L), + ActivePowerPhaseC(2571L), + ActivePowerMinPhaseC(2572L), + ActivePowerMaxPhaseC(2573L), + ReactivePowerPhaseC(2574L), + ApparentPowerPhaseC(2575L), + PowerFactorPhaseC(2576L), + AverageRmsVoltageMeasurementPeriodPhaseC(2577L), + AverageRmsOverVoltageCounterPhaseC(2578L), + AverageRmsUnderVoltageCounterPhaseC(2579L), + RmsExtremeOverVoltagePeriodPhaseC(2580L), + RmsExtremeUnderVoltagePeriodPhaseC(2581L), + RmsVoltageSagPeriodPhaseC(2582L), + RmsVoltageSwellPeriodPhaseC(2583L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + GetProfileInfoCommand(0L), + GetMeasurementProfileCommand(1L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum GetMeasurementProfileCommandCommandField {AttributeId(0),StartTime(1),NumberOfIntervals(2),; + private final int id; + GetMeasurementProfileCommandCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static GetMeasurementProfileCommandCommandField value(int id) throws NoSuchFieldError { + for (GetMeasurementProfileCommandCommandField field : GetMeasurementProfileCommandCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class UnitTesting implements BaseCluster { + public static final long ID = 4294048773L; + public long getID() { + return ID; + } + + public enum Attribute { + Boolean(0L), + Bitmap8(1L), + Bitmap16(2L), + Bitmap32(3L), + Bitmap64(4L), + Int8u(5L), + Int16u(6L), + Int24u(7L), + Int32u(8L), + Int40u(9L), + Int48u(10L), + Int56u(11L), + Int64u(12L), + Int8s(13L), + Int16s(14L), + Int24s(15L), + Int32s(16L), + Int40s(17L), + Int48s(18L), + Int56s(19L), + Int64s(20L), + Enum8(21L), + Enum16(22L), + FloatSingle(23L), + FloatDouble(24L), + OctetString(25L), + ListInt8u(26L), + ListOctetString(27L), + ListStructOctetString(28L), + LongOctetString(29L), + CharString(30L), + LongCharString(31L), + EpochUs(32L), + EpochS(33L), + VendorId(34L), + ListNullablesAndOptionalsStruct(35L), + EnumAttr(36L), + StructAttr(37L), + RangeRestrictedInt8u(38L), + RangeRestrictedInt8s(39L), + RangeRestrictedInt16u(40L), + RangeRestrictedInt16s(41L), + ListLongOctetString(42L), + ListFabricScoped(43L), + TimedWriteBoolean(48L), + GeneralErrorBoolean(49L), + ClusterErrorBoolean(50L), + Unsupported(255L), + NullableBoolean(16384L), + NullableBitmap8(16385L), + NullableBitmap16(16386L), + NullableBitmap32(16387L), + NullableBitmap64(16388L), + NullableInt8u(16389L), + NullableInt16u(16390L), + NullableInt24u(16391L), + NullableInt32u(16392L), + NullableInt40u(16393L), + NullableInt48u(16394L), + NullableInt56u(16395L), + NullableInt64u(16396L), + NullableInt8s(16397L), + NullableInt16s(16398L), + NullableInt24s(16399L), + NullableInt32s(16400L), + NullableInt40s(16401L), + NullableInt48s(16402L), + NullableInt56s(16403L), + NullableInt64s(16404L), + NullableEnum8(16405L), + NullableEnum16(16406L), + NullableFloatSingle(16407L), + NullableFloatDouble(16408L), + NullableOctetString(16409L), + NullableCharString(16414L), + NullableEnumAttr(16420L), + NullableStruct(16421L), + NullableRangeRestrictedInt8u(16422L), + NullableRangeRestrictedInt8s(16423L), + NullableRangeRestrictedInt16u(16424L), + NullableRangeRestrictedInt16s(16425L), + WriteOnlyInt8u(16426L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + TestEvent(1L), + TestFabricScopedEvent(2L),; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Test(0L), + TestNotHandled(1L), + TestSpecific(2L), + TestUnknownCommand(3L), + TestAddArguments(4L), + TestSimpleArgumentRequest(5L), + TestStructArrayArgumentRequest(6L), + TestStructArgumentRequest(7L), + TestNestedStructArgumentRequest(8L), + TestListStructArgumentRequest(9L), + TestListInt8UArgumentRequest(10L), + TestNestedStructListArgumentRequest(11L), + TestListNestedStructListArgumentRequest(12L), + TestListInt8UReverseRequest(13L), + TestEnumsRequest(14L), + TestNullableOptionalRequest(15L), + TestComplexNullableOptionalRequest(16L), + SimpleStructEchoRequest(17L), + TimedInvokeRequest(18L), + TestSimpleOptionalArgumentRequest(19L), + TestEmitTestEventRequest(20L), + TestEmitTestFabricScopedEventRequest(21L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum TestAddArgumentsCommandField {Arg1(0),Arg2(1),; + private final int id; + TestAddArgumentsCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestAddArgumentsCommandField value(int id) throws NoSuchFieldError { + for (TestAddArgumentsCommandField field : TestAddArgumentsCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestSimpleArgumentRequestCommandField {Arg1(0),; + private final int id; + TestSimpleArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestSimpleArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestSimpleArgumentRequestCommandField field : TestSimpleArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestStructArrayArgumentRequestCommandField {Arg1(0),Arg2(1),Arg3(2),Arg4(3),Arg5(4),Arg6(5),; + private final int id; + TestStructArrayArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestStructArrayArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestStructArrayArgumentRequestCommandField field : TestStructArrayArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestStructArgumentRequestCommandField {Arg1(0),; + private final int id; + TestStructArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestStructArgumentRequestCommandField field : TestStructArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestNestedStructArgumentRequestCommandField {Arg1(0),; + private final int id; + TestNestedStructArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestNestedStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestNestedStructArgumentRequestCommandField field : TestNestedStructArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestListStructArgumentRequestCommandField {Arg1(0),; + private final int id; + TestListStructArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestListStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestListStructArgumentRequestCommandField field : TestListStructArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestListInt8UArgumentRequestCommandField {Arg1(0),; + private final int id; + TestListInt8UArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestListInt8UArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestListInt8UArgumentRequestCommandField field : TestListInt8UArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestNestedStructListArgumentRequestCommandField {Arg1(0),; + private final int id; + TestNestedStructListArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestNestedStructListArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestNestedStructListArgumentRequestCommandField field : TestNestedStructListArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestListNestedStructListArgumentRequestCommandField {Arg1(0),; + private final int id; + TestListNestedStructListArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestListNestedStructListArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestListNestedStructListArgumentRequestCommandField field : TestListNestedStructListArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestListInt8UReverseRequestCommandField {Arg1(0),; + private final int id; + TestListInt8UReverseRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestListInt8UReverseRequestCommandField value(int id) throws NoSuchFieldError { + for (TestListInt8UReverseRequestCommandField field : TestListInt8UReverseRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestEnumsRequestCommandField {Arg1(0),Arg2(1),; + private final int id; + TestEnumsRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestEnumsRequestCommandField value(int id) throws NoSuchFieldError { + for (TestEnumsRequestCommandField field : TestEnumsRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestNullableOptionalRequestCommandField {Arg1(0),; + private final int id; + TestNullableOptionalRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestNullableOptionalRequestCommandField value(int id) throws NoSuchFieldError { + for (TestNullableOptionalRequestCommandField field : TestNullableOptionalRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestComplexNullableOptionalRequestCommandField {NullableInt(0),OptionalInt(1),NullableOptionalInt(2),NullableString(3),OptionalString(4),NullableOptionalString(5),NullableStruct(6),OptionalStruct(7),NullableOptionalStruct(8),NullableList(9),OptionalList(10),NullableOptionalList(11),; + private final int id; + TestComplexNullableOptionalRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestComplexNullableOptionalRequestCommandField value(int id) throws NoSuchFieldError { + for (TestComplexNullableOptionalRequestCommandField field : TestComplexNullableOptionalRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum SimpleStructEchoRequestCommandField {Arg1(0),; + private final int id; + SimpleStructEchoRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static SimpleStructEchoRequestCommandField value(int id) throws NoSuchFieldError { + for (SimpleStructEchoRequestCommandField field : SimpleStructEchoRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestSimpleOptionalArgumentRequestCommandField {Arg1(0),; + private final int id; + TestSimpleOptionalArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestSimpleOptionalArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestSimpleOptionalArgumentRequestCommandField field : TestSimpleOptionalArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestEmitTestEventRequestCommandField {Arg1(0),Arg2(1),Arg3(2),; + private final int id; + TestEmitTestEventRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestEmitTestEventRequestCommandField value(int id) throws NoSuchFieldError { + for (TestEmitTestEventRequestCommandField field : TestEmitTestEventRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum TestEmitTestFabricScopedEventRequestCommandField {Arg1(0),; + private final int id; + TestEmitTestFabricScopedEventRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static TestEmitTestFabricScopedEventRequestCommandField value(int id) throws NoSuchFieldError { + for (TestEmitTestFabricScopedEventRequestCommandField field : TestEmitTestFabricScopedEventRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + public static class FaultInjection implements BaseCluster { + public static final long ID = 4294048774L; + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L),; + private final long id; + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event {; + private final long id; + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + FailAtFault(0L), + FailRandomlyAtFault(1L),; + private final long id; + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + }public enum FailAtFaultCommandField {Type(0),Id(1),NumCallsToSkip(2),NumCallsToFail(3),TakeMutex(4),; + private final int id; + FailAtFaultCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static FailAtFaultCommandField value(int id) throws NoSuchFieldError { + for (FailAtFaultCommandField field : FailAtFaultCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }public enum FailRandomlyAtFaultCommandField {Type(0),Id(1),Percentage(2),; + private final int id; + FailRandomlyAtFaultCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + public static FailRandomlyAtFaultCommandField value(int id) throws NoSuchFieldError { + for (FailRandomlyAtFaultCommandField field : FailRandomlyAtFaultCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + }@Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + }} diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index 66c26f27cc3e69..5b92382eff1786 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -24,19989 +24,15592 @@ public class ClusterReadMapping { - private static Map readIdentifyInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readIdentifyIdentifyTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams); - result.put("readIdentifyTimeAttribute", readIdentifyIdentifyTimeAttributeInteractionInfo); - Map readIdentifyIdentifyTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readIdentifyTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTypeCommandParams); - result.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.IdentifyCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIdentifyClusterGeneratedCommandListAttributeCallback(), - readIdentifyGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readIdentifyGeneratedCommandListAttributeInteractionInfo); - Map readIdentifyAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.IdentifyCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIdentifyClusterAcceptedCommandListAttributeCallback(), - readIdentifyAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readIdentifyAcceptedCommandListAttributeInteractionInfo); - Map readIdentifyEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readEventListAttribute( - (ChipClusters.IdentifyCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIdentifyClusterEventListAttributeCallback(), - readIdentifyEventListCommandParams); - result.put("readEventListAttribute", readIdentifyEventListAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams); - result.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIdentifyFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readIdentifyFeatureMapAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - return result; - } - - private static Map readGroupsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readGroupsNameSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams); - result.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.GroupsCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupsClusterGeneratedCommandListAttributeCallback(), - readGroupsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readGroupsGeneratedCommandListAttributeInteractionInfo); - Map readGroupsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.GroupsCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedGroupsClusterAcceptedCommandListAttributeCallback(), - readGroupsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readGroupsAcceptedCommandListAttributeInteractionInfo); - Map readGroupsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readEventListAttribute( - (ChipClusters.GroupsCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedGroupsClusterEventListAttributeCallback(), - readGroupsEventListCommandParams); - result.put("readEventListAttribute", readGroupsEventListAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams); - result.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGroupsFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readGroupsFeatureMapAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readScenesInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readScenesSceneCountCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams); - result.put("readSceneCountAttribute", readScenesSceneCountAttributeInteractionInfo); - Map readScenesCurrentSceneCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesCurrentSceneAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readCurrentSceneAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesCurrentSceneCommandParams); - result.put("readCurrentSceneAttribute", readScenesCurrentSceneAttributeInteractionInfo); - Map readScenesCurrentGroupCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesCurrentGroupAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readCurrentGroupAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesCurrentGroupCommandParams); - result.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readSceneValidAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readScenesSceneValidCommandParams); - result.put("readSceneValidAttribute", readScenesSceneValidAttributeInteractionInfo); - Map readScenesNameSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesNameSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesNameSupportCommandParams); - result.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesLastConfiguredByCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesLastConfiguredByAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readLastConfiguredByAttribute( - (ChipClusters.ScenesCluster.LastConfiguredByAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterLastConfiguredByAttributeCallback(), - readScenesLastConfiguredByCommandParams); - result.put("readLastConfiguredByAttribute", readScenesLastConfiguredByAttributeInteractionInfo); - Map readScenesGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ScenesCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedScenesClusterGeneratedCommandListAttributeCallback(), - readScenesGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readScenesGeneratedCommandListAttributeInteractionInfo); - Map readScenesAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ScenesCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedScenesClusterAcceptedCommandListAttributeCallback(), - readScenesAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readScenesAcceptedCommandListAttributeInteractionInfo); - Map readScenesEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readEventListAttribute( - (ChipClusters.ScenesCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterEventListAttributeCallback(), - readScenesEventListCommandParams); - result.put("readEventListAttribute", readScenesEventListAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams); - result.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readScenesFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readScenesFeatureMapAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOnOffInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readOnOffOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams); - result.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readGlobalSceneControlAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffGlobalSceneControlCommandParams); - result.put( - "readGlobalSceneControlAttribute", readOnOffGlobalSceneControlAttributeInteractionInfo); - Map readOnOffOnTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffOnTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readOnTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffOnTimeCommandParams); - result.put("readOnTimeAttribute", readOnOffOnTimeAttributeInteractionInfo); - Map readOnOffOffWaitTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffOffWaitTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readOffWaitTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffOffWaitTimeCommandParams); - result.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readStartUpOnOffAttribute( - (ChipClusters.OnOffCluster.StartUpOnOffAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterStartUpOnOffAttributeCallback(), - readOnOffStartUpOnOffCommandParams); - result.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OnOffCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedOnOffClusterGeneratedCommandListAttributeCallback(), - readOnOffGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", readOnOffGeneratedCommandListAttributeInteractionInfo); - Map readOnOffAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OnOffCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedOnOffClusterAcceptedCommandListAttributeCallback(), - readOnOffAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readOnOffAcceptedCommandListAttributeInteractionInfo); - Map readOnOffEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readEventListAttribute( - (ChipClusters.OnOffCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterEventListAttributeCallback(), - readOnOffEventListCommandParams); - result.put("readEventListAttribute", readOnOffEventListAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams); - result.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOnOffFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readOnOffFeatureMapAttributeInteractionInfo); - Map readOnOffClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOnOffSwitchConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readOnOffSwitchConfigurationSwitchTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams); - result.put( - "readSwitchTypeAttribute", readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo); - Map readOnOffSwitchConfigurationSwitchActionsCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readSwitchActionsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchActionsCommandParams); - result.put( - "readSwitchActionsAttribute", - readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map - readOnOffSwitchConfigurationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOnOffSwitchConfigurationClusterGeneratedCommandListAttributeCallback(), - readOnOffSwitchConfigurationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOnOffSwitchConfigurationClusterAcceptedCommandListAttributeCallback(), - readOnOffSwitchConfigurationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readEventListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOnOffSwitchConfigurationClusterEventListAttributeCallback(), - readOnOffSwitchConfigurationEventListCommandParams); - result.put( - "readEventListAttribute", readOnOffSwitchConfigurationEventListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOnOffSwitchConfigurationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readLevelControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readLevelControlCurrentLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readCurrentLevelAttribute( - (ChipClusters.LevelControlCluster.CurrentLevelAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedLevelControlClusterCurrentLevelAttributeCallback(), - readLevelControlCurrentLevelCommandParams); - result.put("readCurrentLevelAttribute", readLevelControlCurrentLevelAttributeInteractionInfo); - Map readLevelControlRemainingTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlRemainingTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readRemainingTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlRemainingTimeCommandParams); - result.put("readRemainingTimeAttribute", readLevelControlRemainingTimeAttributeInteractionInfo); - Map readLevelControlMinLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlMinLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMinLevelCommandParams); - result.put("readMinLevelAttribute", readLevelControlMinLevelAttributeInteractionInfo); - Map readLevelControlMaxLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlMaxLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMaxLevelCommandParams); - result.put("readMaxLevelAttribute", readLevelControlMaxLevelAttributeInteractionInfo); - Map readLevelControlCurrentFrequencyCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlCurrentFrequencyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readCurrentFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentFrequencyCommandParams); - result.put( - "readCurrentFrequencyAttribute", readLevelControlCurrentFrequencyAttributeInteractionInfo); - Map readLevelControlMinFrequencyCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlMinFrequencyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readMinFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMinFrequencyCommandParams); - result.put("readMinFrequencyAttribute", readLevelControlMinFrequencyAttributeInteractionInfo); - Map readLevelControlMaxFrequencyCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlMaxFrequencyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readMaxFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMaxFrequencyCommandParams); - result.put("readMaxFrequencyAttribute", readLevelControlMaxFrequencyAttributeInteractionInfo); - Map readLevelControlOptionsCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOptionsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOptionsCommandParams); - result.put("readOptionsAttribute", readLevelControlOptionsAttributeInteractionInfo); - Map readLevelControlOnOffTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnOffTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnOffTransitionTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnOffTransitionTimeCommandParams); - result.put( - "readOnOffTransitionTimeAttribute", - readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnLevelAttribute( - (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterOnLevelAttributeCallback(), - readLevelControlOnLevelCommandParams); - result.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLevelControlClusterOnTransitionTimeAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams); - result.put( - "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOffTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLevelControlClusterOffTransitionTimeAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams); - result.put( - "readOffTransitionTimeAttribute", - readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readDefaultMoveRateAttribute( - (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLevelControlClusterDefaultMoveRateAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams); - result.put( - "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readStartUpCurrentLevelAttribute( - (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLevelControlClusterStartUpCurrentLevelAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams); - result.put( - "readStartUpCurrentLevelAttribute", - readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.LevelControlCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLevelControlClusterGeneratedCommandListAttributeCallback(), - readLevelControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readLevelControlGeneratedCommandListAttributeInteractionInfo); - Map readLevelControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.LevelControlCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLevelControlClusterAcceptedCommandListAttributeCallback(), - readLevelControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readLevelControlAcceptedCommandListAttributeInteractionInfo); - Map readLevelControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.LevelControlCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterEventListAttributeCallback(), - readLevelControlEventListCommandParams); - result.put("readEventListAttribute", readLevelControlEventListAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams); - result.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readLevelControlFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readLevelControlFeatureMapAttributeInteractionInfo); - Map readLevelControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBinaryInputBasicInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBinaryInputBasicActiveTextCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicActiveTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readActiveTextAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBinaryInputBasicActiveTextCommandParams); - result.put("readActiveTextAttribute", readBinaryInputBasicActiveTextAttributeInteractionInfo); - Map readBinaryInputBasicDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBinaryInputBasicDescriptionCommandParams); - result.put("readDescriptionAttribute", readBinaryInputBasicDescriptionAttributeInteractionInfo); - Map readBinaryInputBasicInactiveTextCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicInactiveTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readInactiveTextAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBinaryInputBasicInactiveTextCommandParams); - result.put( - "readInactiveTextAttribute", readBinaryInputBasicInactiveTextAttributeInteractionInfo); - Map readBinaryInputBasicOutOfServiceCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams); - result.put( - "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPolarityCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPolarityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readPolarityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicPolarityCommandParams); - result.put("readPolarityAttribute", readBinaryInputBasicPolarityAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams); - result.put( - "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicReliabilityCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicReliabilityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readReliabilityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicReliabilityCommandParams); - result.put("readReliabilityAttribute", readBinaryInputBasicReliabilityAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams); - result.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicApplicationTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicApplicationTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readApplicationTypeAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBinaryInputBasicApplicationTypeCommandParams); - result.put( - "readApplicationTypeAttribute", - readBinaryInputBasicApplicationTypeAttributeInteractionInfo); - Map readBinaryInputBasicGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BinaryInputBasicCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBinaryInputBasicClusterGeneratedCommandListAttributeCallback(), - readBinaryInputBasicGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo); - Map readBinaryInputBasicAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BinaryInputBasicCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBinaryInputBasicClusterAcceptedCommandListAttributeCallback(), - readBinaryInputBasicAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo); - Map readBinaryInputBasicEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readEventListAttribute( - (ChipClusters.BinaryInputBasicCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBinaryInputBasicClusterEventListAttributeCallback(), - readBinaryInputBasicEventListCommandParams); - result.put("readEventListAttribute", readBinaryInputBasicEventListAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBinaryInputBasicFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readBinaryInputBasicFeatureMapAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readPulseWidthModulationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readPulseWidthModulationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.PulseWidthModulationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPulseWidthModulationClusterGeneratedCommandListAttributeCallback(), - readPulseWidthModulationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo); - Map readPulseWidthModulationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.PulseWidthModulationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPulseWidthModulationClusterAcceptedCommandListAttributeCallback(), - readPulseWidthModulationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo); - Map readPulseWidthModulationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readPulseWidthModulationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster) - .readEventListAttribute( - (ChipClusters.PulseWidthModulationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPulseWidthModulationClusterEventListAttributeCallback(), - readPulseWidthModulationEventListCommandParams); - result.put("readEventListAttribute", readPulseWidthModulationEventListAttributeInteractionInfo); - Map readPulseWidthModulationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPulseWidthModulationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PulseWidthModulationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPulseWidthModulationClusterAttributeListAttributeCallback(), - readPulseWidthModulationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readPulseWidthModulationAttributeListAttributeInteractionInfo); - Map readPulseWidthModulationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPulseWidthModulationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPulseWidthModulationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readPulseWidthModulationFeatureMapAttributeInteractionInfo); - Map readPulseWidthModulationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPulseWidthModulationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPulseWidthModulationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readPulseWidthModulationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readDescriptorInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readDescriptorDeviceTypeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorDeviceTypeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readDeviceTypeListAttribute( - (ChipClusters.DescriptorCluster.DeviceTypeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedDescriptorClusterDeviceTypeListAttributeCallback(), - readDescriptorDeviceTypeListCommandParams); - result.put("readDeviceTypeListAttribute", readDescriptorDeviceTypeListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readServerListAttribute( - (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams); - result.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readClientListAttribute( - (ChipClusters.DescriptorCluster.ClientListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterClientListAttributeCallback(), - readDescriptorClientListCommandParams); - result.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readPartsListAttribute( - (ChipClusters.DescriptorCluster.PartsListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterPartsListAttributeCallback(), - readDescriptorPartsListCommandParams); - result.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.DescriptorCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDescriptorClusterGeneratedCommandListAttributeCallback(), - readDescriptorGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readDescriptorGeneratedCommandListAttributeInteractionInfo); - Map readDescriptorAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.DescriptorCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDescriptorClusterAcceptedCommandListAttributeCallback(), - readDescriptorAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readDescriptorAcceptedCommandListAttributeInteractionInfo); - Map readDescriptorEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readEventListAttribute( - (ChipClusters.DescriptorCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterEventListAttributeCallback(), - readDescriptorEventListCommandParams); - result.put("readEventListAttribute", readDescriptorEventListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams); - result.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDescriptorFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readDescriptorFeatureMapAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBindingInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBindingBindingCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingBindingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readBindingAttribute( - (ChipClusters.BindingCluster.BindingAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterBindingAttributeCallback(), - readBindingBindingCommandParams); - result.put("readBindingAttribute", readBindingBindingAttributeInteractionInfo); - Map readBindingGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BindingCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBindingClusterGeneratedCommandListAttributeCallback(), - readBindingGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBindingGeneratedCommandListAttributeInteractionInfo); - Map readBindingAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BindingCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBindingClusterAcceptedCommandListAttributeCallback(), - readBindingAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readBindingAcceptedCommandListAttributeInteractionInfo); - Map readBindingEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readEventListAttribute( - (ChipClusters.BindingCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterEventListAttributeCallback(), - readBindingEventListCommandParams); - result.put("readEventListAttribute", readBindingEventListAttributeInteractionInfo); - Map readBindingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams); - result.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBindingFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readBindingFeatureMapAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readAccessControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readAccessControlAclCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAclAttribute( - (ChipClusters.AccessControlCluster.AclAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAclAttributeCallback(), - readAccessControlAclCommandParams); - result.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readExtensionAttribute( - (ChipClusters.AccessControlCluster.ExtensionAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterExtensionAttributeCallback(), - readAccessControlExtensionCommandParams); - result.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlSubjectsPerAccessControlEntryCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readSubjectsPerAccessControlEntryAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlSubjectsPerAccessControlEntryCommandParams); - result.put( - "readSubjectsPerAccessControlEntryAttribute", - readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo); - Map readAccessControlTargetsPerAccessControlEntryCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readTargetsPerAccessControlEntryAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlTargetsPerAccessControlEntryCommandParams); - result.put( - "readTargetsPerAccessControlEntryAttribute", - readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo); - Map readAccessControlAccessControlEntriesPerFabricCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAccessControlEntriesPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlAccessControlEntriesPerFabricCommandParams); - result.put( - "readAccessControlEntriesPerFabricAttribute", - readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo); - Map readAccessControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.AccessControlCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccessControlClusterGeneratedCommandListAttributeCallback(), - readAccessControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readAccessControlGeneratedCommandListAttributeInteractionInfo); - Map readAccessControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.AccessControlCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccessControlClusterAcceptedCommandListAttributeCallback(), - readAccessControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readAccessControlAcceptedCommandListAttributeInteractionInfo); - Map readAccessControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.AccessControlCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterEventListAttributeCallback(), - readAccessControlEventListCommandParams); - result.put("readEventListAttribute", readAccessControlEventListAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAccessControlFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readAccessControlFeatureMapAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readActionsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readActionsActionListCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsActionListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readActionListAttribute( - (ChipClusters.ActionsCluster.ActionListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterActionListAttributeCallback(), - readActionsActionListCommandParams); - result.put("readActionListAttribute", readActionsActionListAttributeInteractionInfo); - Map readActionsEndpointListsCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsEndpointListsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readEndpointListsAttribute( - (ChipClusters.ActionsCluster.EndpointListsAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterEndpointListsAttributeCallback(), - readActionsEndpointListsCommandParams); - result.put("readEndpointListsAttribute", readActionsEndpointListsAttributeInteractionInfo); - Map readActionsSetupURLCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsSetupURLAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readSetupURLAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readActionsSetupURLCommandParams); - result.put("readSetupURLAttribute", readActionsSetupURLAttributeInteractionInfo); - Map readActionsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ActionsCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedActionsClusterGeneratedCommandListAttributeCallback(), - readActionsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readActionsGeneratedCommandListAttributeInteractionInfo); - Map readActionsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ActionsCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedActionsClusterAcceptedCommandListAttributeCallback(), - readActionsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readActionsAcceptedCommandListAttributeInteractionInfo); - Map readActionsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readEventListAttribute( - (ChipClusters.ActionsCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterEventListAttributeCallback(), - readActionsEventListCommandParams); - result.put("readEventListAttribute", readActionsEventListAttributeInteractionInfo); - Map readActionsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ActionsCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterAttributeListAttributeCallback(), - readActionsAttributeListCommandParams); - result.put("readAttributeListAttribute", readActionsAttributeListAttributeInteractionInfo); - Map readActionsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readActionsFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readActionsFeatureMapAttributeInteractionInfo); - Map readActionsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readActionsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActionsClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readActionsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBasicInformationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBasicInformationDataModelRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationDataModelRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readDataModelRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationDataModelRevisionCommandParams); - result.put( - "readDataModelRevisionAttribute", - readBasicInformationDataModelRevisionAttributeInteractionInfo); - Map readBasicInformationVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationVendorNameCommandParams); - result.put("readVendorNameAttribute", readBasicInformationVendorNameAttributeInteractionInfo); - Map readBasicInformationVendorIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationVendorIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationVendorIDCommandParams); - result.put("readVendorIDAttribute", readBasicInformationVendorIDAttributeInteractionInfo); - Map readBasicInformationProductNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationProductNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationProductNameCommandParams); - result.put("readProductNameAttribute", readBasicInformationProductNameAttributeInteractionInfo); - Map readBasicInformationProductIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationProductIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationProductIDCommandParams); - result.put("readProductIDAttribute", readBasicInformationProductIDAttributeInteractionInfo); - Map readBasicInformationNodeLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationNodeLabelCommandParams); - result.put("readNodeLabelAttribute", readBasicInformationNodeLabelAttributeInteractionInfo); - Map readBasicInformationLocationCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationLocationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationLocationCommandParams); - result.put("readLocationAttribute", readBasicInformationLocationAttributeInteractionInfo); - Map readBasicInformationHardwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationHardwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationHardwareVersionCommandParams); - result.put( - "readHardwareVersionAttribute", - readBasicInformationHardwareVersionAttributeInteractionInfo); - Map readBasicInformationHardwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationHardwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readHardwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationHardwareVersionStringCommandParams); - result.put( - "readHardwareVersionStringAttribute", - readBasicInformationHardwareVersionStringAttributeInteractionInfo); - Map readBasicInformationSoftwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationSoftwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicInformationSoftwareVersionCommandParams); - result.put( - "readSoftwareVersionAttribute", - readBasicInformationSoftwareVersionAttributeInteractionInfo); - Map readBasicInformationSoftwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationSoftwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readSoftwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationSoftwareVersionStringCommandParams); - result.put( - "readSoftwareVersionStringAttribute", - readBasicInformationSoftwareVersionStringAttributeInteractionInfo); - Map readBasicInformationManufacturingDateCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationManufacturingDateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readManufacturingDateAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationManufacturingDateCommandParams); - result.put( - "readManufacturingDateAttribute", - readBasicInformationManufacturingDateAttributeInteractionInfo); - Map readBasicInformationPartNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationPartNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationPartNumberCommandParams); - result.put("readPartNumberAttribute", readBasicInformationPartNumberAttributeInteractionInfo); - Map readBasicInformationProductURLCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationProductURLAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationProductURLCommandParams); - result.put("readProductURLAttribute", readBasicInformationProductURLAttributeInteractionInfo); - Map readBasicInformationProductLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationProductLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationProductLabelCommandParams); - result.put( - "readProductLabelAttribute", readBasicInformationProductLabelAttributeInteractionInfo); - Map readBasicInformationSerialNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationSerialNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationSerialNumberCommandParams); - result.put( - "readSerialNumberAttribute", readBasicInformationSerialNumberAttributeInteractionInfo); - Map readBasicInformationLocalConfigDisabledCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationLocalConfigDisabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readLocalConfigDisabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicInformationLocalConfigDisabledCommandParams); - result.put( - "readLocalConfigDisabledAttribute", - readBasicInformationLocalConfigDisabledAttributeInteractionInfo); - Map readBasicInformationReachableCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationReachableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicInformationReachableCommandParams); - result.put("readReachableAttribute", readBasicInformationReachableAttributeInteractionInfo); - Map readBasicInformationUniqueIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationUniqueIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationUniqueIDCommandParams); - result.put("readUniqueIDAttribute", readBasicInformationUniqueIDAttributeInteractionInfo); - Map readBasicInformationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BasicInformationCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBasicInformationClusterGeneratedCommandListAttributeCallback(), - readBasicInformationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBasicInformationGeneratedCommandListAttributeInteractionInfo); - Map readBasicInformationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BasicInformationCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBasicInformationClusterAcceptedCommandListAttributeCallback(), - readBasicInformationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readBasicInformationAcceptedCommandListAttributeInteractionInfo); - Map readBasicInformationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readEventListAttribute( - (ChipClusters.BasicInformationCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBasicInformationClusterEventListAttributeCallback(), - readBasicInformationEventListCommandParams); - result.put("readEventListAttribute", readBasicInformationEventListAttributeInteractionInfo); - Map readBasicInformationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BasicInformationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBasicInformationClusterAttributeListAttributeCallback(), - readBasicInformationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readBasicInformationAttributeListAttributeInteractionInfo); - Map readBasicInformationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicInformationFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readBasicInformationFeatureMapAttributeInteractionInfo); - Map readBasicInformationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInformationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readBasicInformationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOtaSoftwareUpdateProviderInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map - readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateProviderClusterGeneratedCommandListAttributeCallback(), - readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo); - Map - readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateProviderClusterAcceptedCommandListAttributeCallback(), - readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readEventListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateProviderClusterEventListAttributeCallback(), - readOtaSoftwareUpdateProviderEventListCommandParams); - result.put( - "readEventListAttribute", readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOtaSoftwareUpdateProviderFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOtaSoftwareUpdateRequestorInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map - readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readDefaultOTAProvidersAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .DefaultOTAProvidersAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterDefaultOTAProvidersAttributeCallback(), - readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams); - result.put( - "readDefaultOTAProvidersAttribute", - readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdatePossibleAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams); - result.put( - "readUpdatePossibleAttribute", - readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdateStateCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdateStateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateCommandParams); - result.put( - "readUpdateStateAttribute", - readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdateStateProgressAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .UpdateStateProgressAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterUpdateStateProgressAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); - result.put( - "readUpdateStateProgressAttribute", - readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map - readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterGeneratedCommandListAttributeCallback(), - readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo); - Map - readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterAcceptedCommandListAttributeCallback(), - readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readEventListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterEventListAttributeCallback(), - readOtaSoftwareUpdateRequestorEventListCommandParams); - result.put( - "readEventListAttribute", readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOtaSoftwareUpdateRequestorFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readLocalizationConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readLocalizationConfigurationActiveLocaleCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams); - result.put( - "readActiveLocaleAttribute", - readLocalizationConfigurationActiveLocaleAttributeInteractionInfo); - Map readLocalizationConfigurationSupportedLocalesCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readSupportedLocalesAttribute( - (ChipClusters.LocalizationConfigurationCluster - .SupportedLocalesAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback(), - readLocalizationConfigurationSupportedLocalesCommandParams); - result.put( - "readSupportedLocalesAttribute", - readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map - readLocalizationConfigurationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.LocalizationConfigurationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLocalizationConfigurationClusterGeneratedCommandListAttributeCallback(), - readLocalizationConfigurationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo); - Map - readLocalizationConfigurationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.LocalizationConfigurationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLocalizationConfigurationClusterAcceptedCommandListAttributeCallback(), - readLocalizationConfigurationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readLocalizationConfigurationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readEventListAttribute( - (ChipClusters.LocalizationConfigurationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLocalizationConfigurationClusterEventListAttributeCallback(), - readLocalizationConfigurationEventListCommandParams); - result.put( - "readEventListAttribute", readLocalizationConfigurationEventListAttributeInteractionInfo); - Map readLocalizationConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LocalizationConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLocalizationConfigurationClusterAttributeListAttributeCallback(), - readLocalizationConfigurationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readLocalizationConfigurationAttributeListAttributeInteractionInfo); - Map readLocalizationConfigurationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readLocalizationConfigurationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readLocalizationConfigurationFeatureMapAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readTimeFormatLocalizationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readTimeFormatLocalizationHourFormatCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams); - result.put( - "readHourFormatAttribute", readTimeFormatLocalizationHourFormatAttributeInteractionInfo); - Map readTimeFormatLocalizationActiveCalendarTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readActiveCalendarTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationActiveCalendarTypeCommandParams); - result.put( - "readActiveCalendarTypeAttribute", - readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); - Map - readTimeFormatLocalizationSupportedCalendarTypesCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readSupportedCalendarTypesAttribute( - (ChipClusters.TimeFormatLocalizationCluster - .SupportedCalendarTypesAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback(), - readTimeFormatLocalizationSupportedCalendarTypesCommandParams); - result.put( - "readSupportedCalendarTypesAttribute", - readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.TimeFormatLocalizationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeFormatLocalizationClusterGeneratedCommandListAttributeCallback(), - readTimeFormatLocalizationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo); - Map readTimeFormatLocalizationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.TimeFormatLocalizationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeFormatLocalizationClusterAcceptedCommandListAttributeCallback(), - readTimeFormatLocalizationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo); - Map readTimeFormatLocalizationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readEventListAttribute( - (ChipClusters.TimeFormatLocalizationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeFormatLocalizationClusterEventListAttributeCallback(), - readTimeFormatLocalizationEventListCommandParams); - result.put( - "readEventListAttribute", readTimeFormatLocalizationEventListAttributeInteractionInfo); - Map readTimeFormatLocalizationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TimeFormatLocalizationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeFormatLocalizationClusterAttributeListAttributeCallback(), - readTimeFormatLocalizationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readTimeFormatLocalizationAttributeListAttributeInteractionInfo); - Map readTimeFormatLocalizationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTimeFormatLocalizationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readTimeFormatLocalizationFeatureMapAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readUnitLocalizationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readUnitLocalizationTemperatureUnitCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams); - result.put( - "readTemperatureUnitAttribute", - readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.UnitLocalizationCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitLocalizationClusterGeneratedCommandListAttributeCallback(), - readUnitLocalizationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readUnitLocalizationGeneratedCommandListAttributeInteractionInfo); - Map readUnitLocalizationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.UnitLocalizationCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitLocalizationClusterAcceptedCommandListAttributeCallback(), - readUnitLocalizationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readUnitLocalizationAcceptedCommandListAttributeInteractionInfo); - Map readUnitLocalizationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readEventListAttribute( - (ChipClusters.UnitLocalizationCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitLocalizationClusterEventListAttributeCallback(), - readUnitLocalizationEventListCommandParams); - result.put("readEventListAttribute", readUnitLocalizationEventListAttributeInteractionInfo); - Map readUnitLocalizationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.UnitLocalizationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitLocalizationClusterAttributeListAttributeCallback(), - readUnitLocalizationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readUnitLocalizationAttributeListAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readUnitLocalizationFeatureMapAttributeInteractionInfo); - Map readUnitLocalizationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readUnitLocalizationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readPowerSourceConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readPowerSourceConfigurationSourcesCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationSourcesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readSourcesAttribute( - (ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback(), - readPowerSourceConfigurationSourcesCommandParams); - result.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map - readPowerSourceConfigurationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.PowerSourceConfigurationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterGeneratedCommandListAttributeCallback(), - readPowerSourceConfigurationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readPowerSourceConfigurationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.PowerSourceConfigurationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterAcceptedCommandListAttributeCallback(), - readPowerSourceConfigurationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readPowerSourceConfigurationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readEventListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterEventListAttributeCallback(), - readPowerSourceConfigurationEventListCommandParams); - result.put( - "readEventListAttribute", readPowerSourceConfigurationEventListAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceConfigurationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readPowerSourceConfigurationFeatureMapAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readPowerSourceInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readPowerSourceStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams); - result.put("readStatusAttribute", readPowerSourceStatusAttributeInteractionInfo); - Map readPowerSourceOrderCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceOrderAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readOrderAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceOrderCommandParams); - result.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceDescriptionCommandParams); - result.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceWiredAssessedInputVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredAssessedInputVoltageAttribute( - (ChipClusters.PowerSourceCluster.WiredAssessedInputVoltageAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterWiredAssessedInputVoltageAttributeCallback(), - readPowerSourceWiredAssessedInputVoltageCommandParams); - result.put( - "readWiredAssessedInputVoltageAttribute", - readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo); - Map readPowerSourceWiredAssessedInputFrequencyCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredAssessedInputFrequencyAttribute( - (ChipClusters.PowerSourceCluster.WiredAssessedInputFrequencyAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterWiredAssessedInputFrequencyAttributeCallback(), - readPowerSourceWiredAssessedInputFrequencyCommandParams); - result.put( - "readWiredAssessedInputFrequencyAttribute", - readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo); - Map readPowerSourceWiredCurrentTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredCurrentTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredCurrentTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceWiredCurrentTypeCommandParams); - result.put( - "readWiredCurrentTypeAttribute", readPowerSourceWiredCurrentTypeAttributeInteractionInfo); - Map readPowerSourceWiredAssessedCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredAssessedCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredAssessedCurrentAttribute( - (ChipClusters.PowerSourceCluster.WiredAssessedCurrentAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterWiredAssessedCurrentAttributeCallback(), - readPowerSourceWiredAssessedCurrentCommandParams); - result.put( - "readWiredAssessedCurrentAttribute", - readPowerSourceWiredAssessedCurrentAttributeInteractionInfo); - Map readPowerSourceWiredNominalVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredNominalVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredNominalVoltageAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceWiredNominalVoltageCommandParams); - result.put( - "readWiredNominalVoltageAttribute", - readPowerSourceWiredNominalVoltageAttributeInteractionInfo); - Map readPowerSourceWiredMaximumCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredMaximumCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredMaximumCurrentAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceWiredMaximumCurrentCommandParams); - result.put( - "readWiredMaximumCurrentAttribute", - readPowerSourceWiredMaximumCurrentAttributeInteractionInfo); - Map readPowerSourceWiredPresentCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceWiredPresentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readWiredPresentAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceWiredPresentCommandParams); - result.put("readWiredPresentAttribute", readPowerSourceWiredPresentAttributeInteractionInfo); - Map readPowerSourceActiveWiredFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceActiveWiredFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readActiveWiredFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveWiredFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterActiveWiredFaultsAttributeCallback(), - readPowerSourceActiveWiredFaultsCommandParams); - result.put( - "readActiveWiredFaultsAttribute", readPowerSourceActiveWiredFaultsAttributeInteractionInfo); - Map readPowerSourceBatVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatVoltageAttribute( - (ChipClusters.PowerSourceCluster.BatVoltageAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatVoltageAttributeCallback(), - readPowerSourceBatVoltageCommandParams); - result.put("readBatVoltageAttribute", readPowerSourceBatVoltageAttributeInteractionInfo); - Map readPowerSourceBatPercentRemainingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatPercentRemainingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatPercentRemainingAttribute( - (ChipClusters.PowerSourceCluster.BatPercentRemainingAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterBatPercentRemainingAttributeCallback(), - readPowerSourceBatPercentRemainingCommandParams); - result.put( - "readBatPercentRemainingAttribute", - readPowerSourceBatPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatTimeRemainingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatTimeRemainingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatTimeRemainingAttribute( - (ChipClusters.PowerSourceCluster.BatTimeRemainingAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterBatTimeRemainingAttributeCallback(), - readPowerSourceBatTimeRemainingCommandParams); - result.put( - "readBatTimeRemainingAttribute", readPowerSourceBatTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatChargeLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatChargeLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatChargeLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatChargeLevelCommandParams); - result.put( - "readBatChargeLevelAttribute", readPowerSourceBatChargeLevelAttributeInteractionInfo); - Map readPowerSourceBatReplacementNeededCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatReplacementNeededAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatReplacementNeededAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceBatReplacementNeededCommandParams); - result.put( - "readBatReplacementNeededAttribute", - readPowerSourceBatReplacementNeededAttributeInteractionInfo); - Map readPowerSourceBatReplaceabilityCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatReplaceabilityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatReplaceabilityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatReplaceabilityCommandParams); - result.put( - "readBatReplaceabilityAttribute", readPowerSourceBatReplaceabilityAttributeInteractionInfo); - Map readPowerSourceBatPresentCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatPresentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatPresentAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceBatPresentCommandParams); - result.put("readBatPresentAttribute", readPowerSourceBatPresentAttributeInteractionInfo); - Map readPowerSourceActiveBatFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readActiveBatFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveBatFaultsAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterActiveBatFaultsAttributeCallback(), - readPowerSourceActiveBatFaultsCommandParams); - result.put( - "readActiveBatFaultsAttribute", readPowerSourceActiveBatFaultsAttributeInteractionInfo); - Map readPowerSourceBatReplacementDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatReplacementDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatReplacementDescriptionAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceBatReplacementDescriptionCommandParams); - result.put( - "readBatReplacementDescriptionAttribute", - readPowerSourceBatReplacementDescriptionAttributeInteractionInfo); - Map readPowerSourceBatCommonDesignationCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatCommonDesignationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatCommonDesignationAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatCommonDesignationCommandParams); - result.put( - "readBatCommonDesignationAttribute", - readPowerSourceBatCommonDesignationAttributeInteractionInfo); - Map readPowerSourceBatANSIDesignationCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatANSIDesignationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatANSIDesignationAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceBatANSIDesignationCommandParams); - result.put( - "readBatANSIDesignationAttribute", - readPowerSourceBatANSIDesignationAttributeInteractionInfo); - Map readPowerSourceBatIECDesignationCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatIECDesignationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatIECDesignationAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceBatIECDesignationCommandParams); - result.put( - "readBatIECDesignationAttribute", readPowerSourceBatIECDesignationAttributeInteractionInfo); - Map readPowerSourceBatApprovedChemistryCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatApprovedChemistryAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatApprovedChemistryAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatApprovedChemistryCommandParams); - result.put( - "readBatApprovedChemistryAttribute", - readPowerSourceBatApprovedChemistryAttributeInteractionInfo); - Map readPowerSourceBatCapacityCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatCapacityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatCapacityAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatCapacityCommandParams); - result.put("readBatCapacityAttribute", readPowerSourceBatCapacityAttributeInteractionInfo); - Map readPowerSourceBatQuantityCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatQuantityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatQuantityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatQuantityCommandParams); - result.put("readBatQuantityAttribute", readPowerSourceBatQuantityAttributeInteractionInfo); - Map readPowerSourceBatChargeStateCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatChargeStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatChargeStateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatChargeStateCommandParams); - result.put( - "readBatChargeStateAttribute", readPowerSourceBatChargeStateAttributeInteractionInfo); - Map readPowerSourceBatTimeToFullChargeCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatTimeToFullChargeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatTimeToFullChargeAttribute( - (ChipClusters.PowerSourceCluster.BatTimeToFullChargeAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterBatTimeToFullChargeAttributeCallback(), - readPowerSourceBatTimeToFullChargeCommandParams); - result.put( - "readBatTimeToFullChargeAttribute", - readPowerSourceBatTimeToFullChargeAttributeInteractionInfo); - Map readPowerSourceBatFunctionalWhileChargingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatFunctionalWhileChargingAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceBatFunctionalWhileChargingCommandParams); - result.put( - "readBatFunctionalWhileChargingAttribute", - readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo); - Map readPowerSourceBatChargingCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatChargingCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatChargingCurrentAttribute( - (ChipClusters.PowerSourceCluster.BatChargingCurrentAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterBatChargingCurrentAttributeCallback(), - readPowerSourceBatChargingCurrentCommandParams); - result.put( - "readBatChargingCurrentAttribute", - readPowerSourceBatChargingCurrentAttributeInteractionInfo); - Map readPowerSourceActiveBatChargeFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readActiveBatChargeFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveBatChargeFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterActiveBatChargeFaultsAttributeCallback(), - readPowerSourceActiveBatChargeFaultsCommandParams); - result.put( - "readActiveBatChargeFaultsAttribute", - readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo); - Map readPowerSourceGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.PowerSourceCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterGeneratedCommandListAttributeCallback(), - readPowerSourceGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readPowerSourceGeneratedCommandListAttributeInteractionInfo); - Map readPowerSourceAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.PowerSourceCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterAcceptedCommandListAttributeCallback(), - readPowerSourceAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readPowerSourceAcceptedCommandListAttributeInteractionInfo); - Map readPowerSourceEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readEventListAttribute( - (ChipClusters.PowerSourceCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterEventListAttributeCallback(), - readPowerSourceEventListCommandParams); - result.put("readEventListAttribute", readPowerSourceEventListAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams); - result.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readPowerSourceFeatureMapAttributeInteractionInfo); - Map readPowerSourceClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readGeneralCommissioningInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readGeneralCommissioningBreadcrumbCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams); - result.put( - "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams); - result.put( - "readRegulatoryConfigAttribute", - readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo); - Map readGeneralCommissioningLocationCapabilityCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningLocationCapabilityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readLocationCapabilityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningLocationCapabilityCommandParams); - result.put( - "readLocationCapabilityAttribute", - readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map - readGeneralCommissioningSupportsConcurrentConnectionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readSupportsConcurrentConnectionAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readGeneralCommissioningSupportsConcurrentConnectionCommandParams); - result.put( - "readSupportsConcurrentConnectionAttribute", - readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo); - Map readGeneralCommissioningGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.GeneralCommissioningCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterGeneratedCommandListAttributeCallback(), - readGeneralCommissioningGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo); - Map readGeneralCommissioningAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.GeneralCommissioningCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterAcceptedCommandListAttributeCallback(), - readGeneralCommissioningAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo); - Map readGeneralCommissioningEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readEventListAttribute( - (ChipClusters.GeneralCommissioningCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterEventListAttributeCallback(), - readGeneralCommissioningEventListCommandParams); - result.put("readEventListAttribute", readGeneralCommissioningEventListAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readGeneralCommissioningFeatureMapAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readNetworkCommissioningInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readNetworkCommissioningMaxNetworksCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams); - result.put( - "readMaxNetworksAttribute", readNetworkCommissioningMaxNetworksAttributeInteractionInfo); - Map readNetworkCommissioningNetworksCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningNetworksAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readNetworksAttribute( - (ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterNetworksAttributeCallback(), - readNetworkCommissioningNetworksCommandParams); - result.put("readNetworksAttribute", readNetworkCommissioningNetworksAttributeInteractionInfo); - Map readNetworkCommissioningScanMaxTimeSecondsCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readScanMaxTimeSecondsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningScanMaxTimeSecondsCommandParams); - result.put( - "readScanMaxTimeSecondsAttribute", - readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningConnectMaxTimeSecondsCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readConnectMaxTimeSecondsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningConnectMaxTimeSecondsCommandParams); - result.put( - "readConnectMaxTimeSecondsAttribute", - readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readInterfaceEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readNetworkCommissioningInterfaceEnabledCommandParams); - result.put( - "readInterfaceEnabledAttribute", - readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastNetworkingStatusAttribute( - (ChipClusters.NetworkCommissioningCluster - .LastNetworkingStatusAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterLastNetworkingStatusAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams); - result.put( - "readLastNetworkingStatusAttribute", - readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastNetworkIDAttribute( - (ChipClusters.NetworkCommissioningCluster.LastNetworkIDAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterLastNetworkIDAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams); - result.put( - "readLastNetworkIDAttribute", - readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastConnectErrorValueAttribute( - (ChipClusters.NetworkCommissioningCluster - .LastConnectErrorValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterLastConnectErrorValueAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams); - result.put( - "readLastConnectErrorValueAttribute", - readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.NetworkCommissioningCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterGeneratedCommandListAttributeCallback(), - readNetworkCommissioningGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo); - Map readNetworkCommissioningAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.NetworkCommissioningCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterAcceptedCommandListAttributeCallback(), - readNetworkCommissioningAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo); - Map readNetworkCommissioningEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readEventListAttribute( - (ChipClusters.NetworkCommissioningCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterEventListAttributeCallback(), - readNetworkCommissioningEventListCommandParams); - result.put("readEventListAttribute", readNetworkCommissioningEventListAttributeInteractionInfo); - Map readNetworkCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.NetworkCommissioningCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedNetworkCommissioningClusterAttributeListAttributeCallback(), - readNetworkCommissioningAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readNetworkCommissioningAttributeListAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readNetworkCommissioningFeatureMapAttributeInteractionInfo); - Map readNetworkCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readDiagnosticLogsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readDiagnosticLogsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.DiagnosticLogsCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDiagnosticLogsClusterGeneratedCommandListAttributeCallback(), - readDiagnosticLogsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo); - Map readDiagnosticLogsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.DiagnosticLogsCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDiagnosticLogsClusterAcceptedCommandListAttributeCallback(), - readDiagnosticLogsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo); - Map readDiagnosticLogsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readEventListAttribute( - (ChipClusters.DiagnosticLogsCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterEventListAttributeCallback(), - readDiagnosticLogsEventListCommandParams); - result.put("readEventListAttribute", readDiagnosticLogsEventListAttributeInteractionInfo); - Map readDiagnosticLogsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - Map readDiagnosticLogsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDiagnosticLogsFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readDiagnosticLogsFeatureMapAttributeInteractionInfo); - Map readDiagnosticLogsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDiagnosticLogsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readDiagnosticLogsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readGeneralDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readGeneralDiagnosticsNetworkInterfacesCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readNetworkInterfacesAttribute( - (ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback(), - readGeneralDiagnosticsNetworkInterfacesCommandParams); - result.put( - "readNetworkInterfacesAttribute", - readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo); - Map readGeneralDiagnosticsRebootCountCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsRebootCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readRebootCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsRebootCountCommandParams); - result.put( - "readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readUpTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralDiagnosticsUpTimeCommandParams); - result.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readTotalOperationalHoursAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralDiagnosticsTotalOperationalHoursCommandParams); - result.put( - "readTotalOperationalHoursAttribute", - readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readBootReasonAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonCommandParams); - result.put("readBootReasonAttribute", readGeneralDiagnosticsBootReasonAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readActiveHardwareFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams); - result.put( - "readActiveHardwareFaultsAttribute", - readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveRadioFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readActiveRadioFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback(), - readGeneralDiagnosticsActiveRadioFaultsCommandParams); - result.put( - "readActiveRadioFaultsAttribute", - readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveNetworkFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readActiveNetworkFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback(), - readGeneralDiagnosticsActiveNetworkFaultsCommandParams); - result.put( - "readActiveNetworkFaultsAttribute", - readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsTestEventTriggersEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readTestEventTriggersEnabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readGeneralDiagnosticsTestEventTriggersEnabledCommandParams); - result.put( - "readTestEventTriggersEnabledAttribute", - readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo); - Map readGeneralDiagnosticsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readGeneralDiagnosticsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readGeneralDiagnosticsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readGeneralDiagnosticsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readGeneralDiagnosticsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readEventListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterEventListAttributeCallback(), - readGeneralDiagnosticsEventListCommandParams); - result.put("readEventListAttribute", readGeneralDiagnosticsEventListAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralDiagnosticsFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readGeneralDiagnosticsFeatureMapAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readSoftwareDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readSoftwareDiagnosticsThreadMetricsCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readThreadMetricsAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback(), - readSoftwareDiagnosticsThreadMetricsCommandParams); - result.put( - "readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapFreeAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsCurrentHeapFreeCommandParams); - result.put( - "readCurrentHeapFreeAttribute", - readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapUsedAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsCurrentHeapUsedCommandParams); - result.put( - "readCurrentHeapUsedAttribute", - readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapHighWatermarkAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams); - result.put( - "readCurrentHeapHighWatermarkAttribute", - readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readSoftwareDiagnosticsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readSoftwareDiagnosticsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readSoftwareDiagnosticsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readSoftwareDiagnosticsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readEventListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterEventListAttributeCallback(), - readSoftwareDiagnosticsEventListCommandParams); - result.put("readEventListAttribute", readSoftwareDiagnosticsEventListAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo); - Map readSoftwareDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSoftwareDiagnosticsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readThreadNetworkDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readThreadNetworkDiagnosticsChannelCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChannelAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ChannelAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterChannelAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams); - result.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRoutingRoleAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.RoutingRoleAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams); - result.put( - "readRoutingRoleAttribute", - readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readNetworkNameAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.NetworkNameAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterNetworkNameAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams); - result.put( - "readNetworkNameAttribute", - readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPanIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.PanIdAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterPanIdAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams); - result.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readExtendedPanIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ExtendedPanIdAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterExtendedPanIdAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams); - result.put( - "readExtendedPanIdAttribute", - readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readMeshLocalPrefixAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .MeshLocalPrefixAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterMeshLocalPrefixAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); - result.put( - "readMeshLocalPrefixAttribute", - readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsOverrunCountCommandParams); - result.put( - "readOverrunCountAttribute", - readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readNeighborTableAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterNeighborTableAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableCommandParams); - result.put( - "readNeighborTableAttribute", - readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRouteTableAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterRouteTableAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableCommandParams); - result.put( - "readRouteTableAttribute", readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPartitionIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.PartitionIdAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterPartitionIdAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams); - result.put( - "readPartitionIdAttribute", - readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readWeightingAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.WeightingAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterWeightingAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams); - result.put( - "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDataVersionAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.DataVersionAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterDataVersionAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams); - result.put( - "readDataVersionAttribute", - readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readStableDataVersionAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .StableDataVersionAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterStableDataVersionAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams); - result.put( - "readStableDataVersionAttribute", - readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readLeaderRouterIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.LeaderRouterIdAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterLeaderRouterIdAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); - result.put( - "readLeaderRouterIdAttribute", - readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDetachedRoleCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDetachedRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDetachedRoleCountCommandParams); - result.put( - "readDetachedRoleCountAttribute", - readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChildRoleCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChildRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChildRoleCountCommandParams); - result.put( - "readChildRoleCountAttribute", - readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouterRoleCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRouterRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRouterRoleCountCommandParams); - result.put( - "readRouterRoleCountAttribute", - readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRoleCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readLeaderRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRoleCountCommandParams); - result.put( - "readLeaderRoleCountAttribute", - readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttachAttemptCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readAttachAttemptCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsAttachAttemptCountCommandParams); - result.put( - "readAttachAttemptCountAttribute", - readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPartitionIdChangeCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams); - result.put( - "readPartitionIdChangeCountAttribute", - readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams = - new LinkedHashMap(); - InteractionInfo - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readBetterPartitionAttachAttemptCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams); - result.put( - "readBetterPartitionAttachAttemptCountAttribute", - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsParentChangeCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readParentChangeCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsParentChangeCountCommandParams); - result.put( - "readParentChangeCountAttribute", - readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxTotalCountCommandParams); - result.put( - "readTxTotalCountAttribute", - readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxUnicastCountCommandParams); - result.put( - "readTxUnicastCountAttribute", - readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxBroadcastCountCommandParams); - result.put( - "readTxBroadcastCountAttribute", - readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxAckRequestedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams); - result.put( - "readTxAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxAckedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxAckedCountCommandParams); - result.put( - "readTxAckedCountAttribute", - readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxNoAckRequestedCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams); - result.put( - "readTxNoAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDataCountCommandParams); - result.put( - "readTxDataCountAttribute", - readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDataPollCountCommandParams); - result.put( - "readTxDataPollCountAttribute", - readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxBeaconCountCommandParams); - result.put( - "readTxBeaconCountAttribute", - readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams); - result.put( - "readTxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxOtherCountCommandParams); - result.put( - "readTxOtherCountAttribute", - readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxRetryCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxRetryCountCommandParams); - result.put( - "readTxRetryCountAttribute", - readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = - new LinkedHashMap(); - InteractionInfo - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDirectMaxRetryExpiryCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams); - result.put( - "readTxDirectMaxRetryExpiryCountAttribute", - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = - new LinkedHashMap(); - InteractionInfo - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxIndirectMaxRetryExpiryCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams); - result.put( - "readTxIndirectMaxRetryExpiryCountAttribute", - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); - result.put( - "readTxErrCcaCountAttribute", - readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); - result.put( - "readTxErrAbortCountAttribute", - readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrBusyChannelCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); - result.put( - "readTxErrBusyChannelCountAttribute", - readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams); - result.put( - "readRxTotalCountAttribute", - readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams); - result.put( - "readRxUnicastCountAttribute", - readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); - result.put( - "readRxBroadcastCountAttribute", - readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams); - result.put( - "readRxDataCountAttribute", - readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams); - result.put( - "readRxDataPollCountAttribute", - readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams); - result.put( - "readRxBeaconCountAttribute", - readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); - result.put( - "readRxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams); - result.put( - "readRxOtherCountAttribute", - readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxAddressFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); - result.put( - "readRxAddressFilteredCountAttribute", - readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDestAddrFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); - result.put( - "readRxDestAddrFilteredCountAttribute", - readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); - result.put( - "readRxDuplicatedCountAttribute", - readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); - result.put( - "readRxErrNoFrameCountAttribute", - readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrUnknownNeighborCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); - result.put( - "readRxErrUnknownNeighborCountAttribute", - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrInvalidSrcAddrCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); - result.put( - "readRxErrInvalidSrcAddrCountAttribute", - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams); - result.put( - "readRxErrSecCountAttribute", - readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); - result.put( - "readRxErrFcsCountAttribute", - readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); - result.put( - "readRxErrOtherCountAttribute", - readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readActiveTimestampAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .ActiveTimestampAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterActiveTimestampAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams); - result.put( - "readActiveTimestampAttribute", - readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPendingTimestampAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .PendingTimestampAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterPendingTimestampAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams); - result.put( - "readPendingTimestampAttribute", - readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDelayAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.DelayAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterDelayAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams); - result.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelPage0MaskCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChannelPage0MaskAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .ChannelPage0MaskAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterChannelPage0MaskAttributeCallback(), - readThreadNetworkDiagnosticsChannelPage0MaskCommandParams); - result.put( - "readChannelPage0MaskAttribute", - readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readActiveNetworkFaultsListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .ActiveNetworkFaultsListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); - result.put( - "readActiveNetworkFaultsListAttribute", - readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readThreadNetworkDiagnosticsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readThreadNetworkDiagnosticsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readEventListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterEventListAttributeCallback(), - readThreadNetworkDiagnosticsEventListCommandParams); - result.put( - "readEventListAttribute", readThreadNetworkDiagnosticsEventListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readWiFiNetworkDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readWiFiNetworkDiagnosticsBssidCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBssidAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.BssidAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterBssidAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams); - result.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readSecurityTypeAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.SecurityTypeAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams); - result.put( - "readSecurityTypeAttribute", - readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readWiFiVersionAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.WiFiVersionAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterWiFiVersionAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams); - result.put( - "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readChannelNumberAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.ChannelNumberAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterChannelNumberAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams); - result.put( - "readChannelNumberAttribute", - readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readRssiAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.RssiAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterRssiAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams); - result.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBeaconLostCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconLostCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterBeaconLostCountAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); - result.put( - "readBeaconLostCountAttribute", - readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBeaconRxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconRxCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterBeaconRxCountAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); - result.put( - "readBeaconRxCountAttribute", - readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketMulticastRxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster - .PacketMulticastRxCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastRxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); - result.put( - "readPacketMulticastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketMulticastTxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster - .PacketMulticastTxCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastTxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); - result.put( - "readPacketMulticastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketUnicastRxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster - .PacketUnicastRxCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastRxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); - result.put( - "readPacketUnicastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketUnicastTxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster - .PacketUnicastTxCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastTxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); - result.put( - "readPacketUnicastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readCurrentMaxRateAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.CurrentMaxRateAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterCurrentMaxRateAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); - result.put( - "readCurrentMaxRateAttribute", - readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.OverrunCountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterOverrunCountAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams); - result.put( - "readOverrunCountAttribute", - readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readEventListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterEventListAttributeCallback(), - readWiFiNetworkDiagnosticsEventListCommandParams); - result.put( - "readEventListAttribute", readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readEthernetNetworkDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readEthernetNetworkDiagnosticsPHYRateCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPHYRateAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.PHYRateAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterPHYRateAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams); - result.put( - "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readFullDuplexAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.FullDuplexAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterFullDuplexAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams); - result.put( - "readFullDuplexAttribute", - readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPacketRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsPacketRxCountCommandParams); - result.put( - "readPacketRxCountAttribute", - readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPacketTxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsPacketTxCountCommandParams); - result.put( - "readPacketTxCountAttribute", - readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readTxErrCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsTxErrCountCommandParams); - result.put( - "readTxErrCountAttribute", - readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readCollisionCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsCollisionCountCommandParams); - result.put( - "readCollisionCountAttribute", - readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsOverrunCountCommandParams); - result.put( - "readOverrunCountAttribute", - readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readCarrierDetectAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster - .CarrierDetectAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterCarrierDetectAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams); - result.put( - "readCarrierDetectAttribute", - readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readTimeSinceResetAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsTimeSinceResetCommandParams); - result.put( - "readTimeSinceResetAttribute", - readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map - readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map - readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readEventListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterEventListAttributeCallback(), - readEthernetNetworkDiagnosticsEventListCommandParams); - result.put( - "readEventListAttribute", readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readTimeSynchronizationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readTimeSynchronizationUTCTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationUTCTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readUTCTimeAttribute( - (ChipClusters.TimeSynchronizationCluster.UTCTimeAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterUTCTimeAttributeCallback(), - readTimeSynchronizationUTCTimeCommandParams); - result.put("readUTCTimeAttribute", readTimeSynchronizationUTCTimeAttributeInteractionInfo); - Map readTimeSynchronizationGranularityCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationGranularityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readGranularityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationGranularityCommandParams); - result.put( - "readGranularityAttribute", readTimeSynchronizationGranularityAttributeInteractionInfo); - Map readTimeSynchronizationTimeSourceCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeSourceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readTimeSourceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationTimeSourceCommandParams); - result.put( - "readTimeSourceAttribute", readTimeSynchronizationTimeSourceAttributeInteractionInfo); - Map readTimeSynchronizationDefaultNTPCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationDefaultNTPAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readDefaultNTPAttribute( - (ChipClusters.TimeSynchronizationCluster.DefaultNTPAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterDefaultNTPAttributeCallback(), - readTimeSynchronizationDefaultNTPCommandParams); - result.put( - "readDefaultNTPAttribute", readTimeSynchronizationDefaultNTPAttributeInteractionInfo); - Map readTimeSynchronizationTimeZoneCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeZoneAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readTimeZoneAttribute( - (ChipClusters.TimeSynchronizationCluster.TimeZoneAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterTimeZoneAttributeCallback(), - readTimeSynchronizationTimeZoneCommandParams); - result.put("readTimeZoneAttribute", readTimeSynchronizationTimeZoneAttributeInteractionInfo); - Map readTimeSynchronizationDSTOffsetCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationDSTOffsetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readDSTOffsetAttribute( - (ChipClusters.TimeSynchronizationCluster.DSTOffsetAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterDSTOffsetAttributeCallback(), - readTimeSynchronizationDSTOffsetCommandParams); - result.put("readDSTOffsetAttribute", readTimeSynchronizationDSTOffsetAttributeInteractionInfo); - Map readTimeSynchronizationLocalTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationLocalTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readLocalTimeAttribute( - (ChipClusters.TimeSynchronizationCluster.LocalTimeAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterLocalTimeAttributeCallback(), - readTimeSynchronizationLocalTimeCommandParams); - result.put("readLocalTimeAttribute", readTimeSynchronizationLocalTimeAttributeInteractionInfo); - Map readTimeSynchronizationTimeZoneDatabaseCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readTimeZoneDatabaseAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationTimeZoneDatabaseCommandParams); - result.put( - "readTimeZoneDatabaseAttribute", - readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo); - Map readTimeSynchronizationNTPServerAvailableCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readNTPServerAvailableAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTimeSynchronizationNTPServerAvailableCommandParams); - result.put( - "readNTPServerAvailableAttribute", - readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo); - Map readTimeSynchronizationTimeZoneListMaxSizeCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readTimeZoneListMaxSizeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationTimeZoneListMaxSizeCommandParams); - result.put( - "readTimeZoneListMaxSizeAttribute", - readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo); - Map readTimeSynchronizationDSTOffsetListMaxSizeCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readDSTOffsetListMaxSizeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationDSTOffsetListMaxSizeCommandParams); - result.put( - "readDSTOffsetListMaxSizeAttribute", - readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo); - Map readTimeSynchronizationSupportsDNSResolveCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readSupportsDNSResolveAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTimeSynchronizationSupportsDNSResolveCommandParams); - result.put( - "readSupportsDNSResolveAttribute", - readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo); - Map readTimeSynchronizationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.TimeSynchronizationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterGeneratedCommandListAttributeCallback(), - readTimeSynchronizationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo); - Map readTimeSynchronizationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.TimeSynchronizationCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterAcceptedCommandListAttributeCallback(), - readTimeSynchronizationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo); - Map readTimeSynchronizationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readEventListAttribute( - (ChipClusters.TimeSynchronizationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterEventListAttributeCallback(), - readTimeSynchronizationEventListCommandParams); - result.put("readEventListAttribute", readTimeSynchronizationEventListAttributeInteractionInfo); - Map readTimeSynchronizationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TimeSynchronizationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTimeSynchronizationClusterAttributeListAttributeCallback(), - readTimeSynchronizationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readTimeSynchronizationAttributeListAttributeInteractionInfo); - Map readTimeSynchronizationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTimeSynchronizationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readTimeSynchronizationFeatureMapAttributeInteractionInfo); - Map readTimeSynchronizationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeSynchronizationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readTimeSynchronizationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBridgedDeviceBasicInformationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBridgedDeviceBasicInformationVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationVendorNameCommandParams); - result.put( - "readVendorNameAttribute", - readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationVendorIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicInformationVendorIDCommandParams); - result.put( - "readVendorIDAttribute", readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationProductNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationProductNameCommandParams); - result.put( - "readProductNameAttribute", - readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationNodeLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationNodeLabelCommandParams); - result.put( - "readNodeLabelAttribute", - readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationHardwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicInformationHardwareVersionCommandParams); - result.put( - "readHardwareVersionAttribute", - readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationHardwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readHardwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationHardwareVersionStringCommandParams); - result.put( - "readHardwareVersionStringAttribute", - readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationSoftwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBridgedDeviceBasicInformationSoftwareVersionCommandParams); - result.put( - "readSoftwareVersionAttribute", - readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readSoftwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams); - result.put( - "readSoftwareVersionStringAttribute", - readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationManufacturingDateCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readManufacturingDateAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationManufacturingDateCommandParams); - result.put( - "readManufacturingDateAttribute", - readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationPartNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationPartNumberCommandParams); - result.put( - "readPartNumberAttribute", - readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationProductURLCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationProductURLCommandParams); - result.put( - "readProductURLAttribute", - readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationProductLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationProductLabelCommandParams); - result.put( - "readProductLabelAttribute", - readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationSerialNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationSerialNumberCommandParams); - result.put( - "readSerialNumberAttribute", - readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationReachableCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationReachableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBridgedDeviceBasicInformationReachableCommandParams); - result.put( - "readReachableAttribute", - readBridgedDeviceBasicInformationReachableAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationUniqueIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationUniqueIDCommandParams); - result.put( - "readUniqueIDAttribute", readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedDeviceBasicInformationClusterGeneratedCommandListAttributeCallback(), - readBridgedDeviceBasicInformationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedDeviceBasicInformationClusterAcceptedCommandListAttributeCallback(), - readBridgedDeviceBasicInformationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readEventListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedDeviceBasicInformationClusterEventListAttributeCallback(), - readBridgedDeviceBasicInformationEventListCommandParams); - result.put( - "readEventListAttribute", - readBridgedDeviceBasicInformationEventListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedDeviceBasicInformationClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicInformationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBridgedDeviceBasicInformationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo); - Map - readBridgedDeviceBasicInformationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicInformationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readSwitchInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readSwitchNumberOfPositionsCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams); - result.put( - "readNumberOfPositionsAttribute", readSwitchNumberOfPositionsAttributeInteractionInfo); - Map readSwitchCurrentPositionCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchCurrentPositionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readCurrentPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchCurrentPositionCommandParams); - result.put("readCurrentPositionAttribute", readSwitchCurrentPositionAttributeInteractionInfo); - Map readSwitchMultiPressMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchMultiPressMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readMultiPressMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchMultiPressMaxCommandParams); - result.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.SwitchCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSwitchClusterGeneratedCommandListAttributeCallback(), - readSwitchGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readSwitchGeneratedCommandListAttributeInteractionInfo); - Map readSwitchAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.SwitchCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedSwitchClusterAcceptedCommandListAttributeCallback(), - readSwitchAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readSwitchAcceptedCommandListAttributeInteractionInfo); - Map readSwitchEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readEventListAttribute( - (ChipClusters.SwitchCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedSwitchClusterEventListAttributeCallback(), - readSwitchEventListCommandParams); - result.put("readEventListAttribute", readSwitchEventListAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams); - result.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSwitchFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readSwitchFeatureMapAttributeInteractionInfo); - Map readSwitchClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readAdministratorCommissioningInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readAdministratorCommissioningWindowStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams); - result.put( - "readWindowStatusAttribute", - readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAdminFabricIndexAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AdminFabricIndexAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterAdminFabricIndexAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams); - result.put( - "readAdminFabricIndexAttribute", - readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAdminVendorIdAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AdminVendorIdAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterAdminVendorIdAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams); - result.put( - "readAdminVendorIdAttribute", - readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map - readAdministratorCommissioningGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.AdministratorCommissioningCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterGeneratedCommandListAttributeCallback(), - readAdministratorCommissioningGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo); - Map - readAdministratorCommissioningAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterAcceptedCommandListAttributeCallback(), - readAdministratorCommissioningAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo); - Map readAdministratorCommissioningEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readEventListAttribute( - (ChipClusters.AdministratorCommissioningCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterEventListAttributeCallback(), - readAdministratorCommissioningEventListCommandParams); - result.put( - "readEventListAttribute", readAdministratorCommissioningEventListAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAdministratorCommissioningFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readAdministratorCommissioningFeatureMapAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOperationalCredentialsInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readOperationalCredentialsNOCsCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsNOCsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readNOCsAttribute( - (ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterNOCsAttributeCallback(), - readOperationalCredentialsNOCsCommandParams); - result.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readFabricsAttribute( - (ChipClusters.OperationalCredentialsCluster.FabricsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterFabricsAttributeCallback(), - readOperationalCredentialsFabricsCommandParams); - result.put("readFabricsAttribute", readOperationalCredentialsFabricsAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams); - result.put( - "readSupportedFabricsAttribute", - readOperationalCredentialsSupportedFabricsAttributeInteractionInfo); - Map readOperationalCredentialsCommissionedFabricsCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readCommissionedFabricsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCommissionedFabricsCommandParams); - result.put( - "readCommissionedFabricsAttribute", - readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo); - Map - readOperationalCredentialsTrustedRootCertificatesCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readTrustedRootCertificatesAttribute( - (ChipClusters.OperationalCredentialsCluster - .TrustedRootCertificatesAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback(), - readOperationalCredentialsTrustedRootCertificatesCommandParams); - result.put( - "readTrustedRootCertificatesAttribute", - readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readCurrentFabricIndexAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams); - result.put( - "readCurrentFabricIndexAttribute", - readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OperationalCredentialsCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterGeneratedCommandListAttributeCallback(), - readOperationalCredentialsGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo); - Map readOperationalCredentialsAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OperationalCredentialsCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterAcceptedCommandListAttributeCallback(), - readOperationalCredentialsAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo); - Map readOperationalCredentialsEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readEventListAttribute( - (ChipClusters.OperationalCredentialsCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterEventListAttributeCallback(), - readOperationalCredentialsEventListCommandParams); - result.put( - "readEventListAttribute", readOperationalCredentialsEventListAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOperationalCredentialsFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readOperationalCredentialsFeatureMapAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readGroupKeyManagementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readGroupKeyManagementGroupKeyMapCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementGroupKeyMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readGroupKeyMapAttribute( - (ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback(), - readGroupKeyManagementGroupKeyMapCommandParams); - result.put( - "readGroupKeyMapAttribute", readGroupKeyManagementGroupKeyMapAttributeInteractionInfo); - Map readGroupKeyManagementGroupTableCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementGroupTableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readGroupTableAttribute( - (ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterGroupTableAttributeCallback(), - readGroupKeyManagementGroupTableCommandParams); - result.put("readGroupTableAttribute", readGroupKeyManagementGroupTableAttributeInteractionInfo); - Map readGroupKeyManagementMaxGroupsPerFabricCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readMaxGroupsPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementMaxGroupsPerFabricCommandParams); - result.put( - "readMaxGroupsPerFabricAttribute", - readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementMaxGroupKeysPerFabricCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readMaxGroupKeysPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementMaxGroupKeysPerFabricCommandParams); - result.put( - "readMaxGroupKeysPerFabricAttribute", - readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.GroupKeyManagementCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterGeneratedCommandListAttributeCallback(), - readGroupKeyManagementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo); - Map readGroupKeyManagementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.GroupKeyManagementCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterAcceptedCommandListAttributeCallback(), - readGroupKeyManagementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo); - Map readGroupKeyManagementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readEventListAttribute( - (ChipClusters.GroupKeyManagementCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterEventListAttributeCallback(), - readGroupKeyManagementEventListCommandParams); - result.put("readEventListAttribute", readGroupKeyManagementEventListAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGroupKeyManagementFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readGroupKeyManagementFeatureMapAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readFixedLabelInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readFixedLabelLabelListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readLabelListAttribute( - (ChipClusters.FixedLabelCluster.LabelListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterLabelListAttributeCallback(), - readFixedLabelLabelListCommandParams); - result.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.FixedLabelCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFixedLabelClusterGeneratedCommandListAttributeCallback(), - readFixedLabelGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readFixedLabelGeneratedCommandListAttributeInteractionInfo); - Map readFixedLabelAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.FixedLabelCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFixedLabelClusterAcceptedCommandListAttributeCallback(), - readFixedLabelAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readFixedLabelAcceptedCommandListAttributeInteractionInfo); - Map readFixedLabelEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readEventListAttribute( - (ChipClusters.FixedLabelCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterEventListAttributeCallback(), - readFixedLabelEventListCommandParams); - result.put("readEventListAttribute", readFixedLabelEventListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams); - result.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFixedLabelFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readFixedLabelFeatureMapAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readUserLabelInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readUserLabelLabelListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readLabelListAttribute( - (ChipClusters.UserLabelCluster.LabelListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterLabelListAttributeCallback(), - readUserLabelLabelListCommandParams); - result.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.UserLabelCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUserLabelClusterGeneratedCommandListAttributeCallback(), - readUserLabelGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readUserLabelGeneratedCommandListAttributeInteractionInfo); - Map readUserLabelAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.UserLabelCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUserLabelClusterAcceptedCommandListAttributeCallback(), - readUserLabelAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readUserLabelAcceptedCommandListAttributeInteractionInfo); - Map readUserLabelEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readEventListAttribute( - (ChipClusters.UserLabelCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterEventListAttributeCallback(), - readUserLabelEventListCommandParams); - result.put("readEventListAttribute", readUserLabelEventListAttributeInteractionInfo); - Map readUserLabelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.UserLabelCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterAttributeListAttributeCallback(), - readUserLabelAttributeListCommandParams); - result.put("readAttributeListAttribute", readUserLabelAttributeListAttributeInteractionInfo); - Map readUserLabelFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUserLabelFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readUserLabelFeatureMapAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readProxyConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readProxyConfigurationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyConfigurationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ProxyConfigurationCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyConfigurationClusterGeneratedCommandListAttributeCallback(), - readProxyConfigurationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readProxyConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readProxyConfigurationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyConfigurationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ProxyConfigurationCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyConfigurationClusterAcceptedCommandListAttributeCallback(), - readProxyConfigurationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readProxyConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readProxyConfigurationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyConfigurationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster) - .readEventListAttribute( - (ChipClusters.ProxyConfigurationCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyConfigurationClusterEventListAttributeCallback(), - readProxyConfigurationEventListCommandParams); - result.put("readEventListAttribute", readProxyConfigurationEventListAttributeInteractionInfo); - Map readProxyConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ProxyConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyConfigurationClusterAttributeListAttributeCallback(), - readProxyConfigurationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readProxyConfigurationAttributeListAttributeInteractionInfo); - Map readProxyConfigurationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyConfigurationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readProxyConfigurationFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readProxyConfigurationFeatureMapAttributeInteractionInfo); - Map readProxyConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readProxyConfigurationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readProxyConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readProxyDiscoveryInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readProxyDiscoveryGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ProxyDiscoveryCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyDiscoveryClusterGeneratedCommandListAttributeCallback(), - readProxyDiscoveryGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo); - Map readProxyDiscoveryAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ProxyDiscoveryCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyDiscoveryClusterAcceptedCommandListAttributeCallback(), - readProxyDiscoveryAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo); - Map readProxyDiscoveryEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyDiscoveryEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster) - .readEventListAttribute( - (ChipClusters.ProxyDiscoveryCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterEventListAttributeCallback(), - readProxyDiscoveryEventListCommandParams); - result.put("readEventListAttribute", readProxyDiscoveryEventListAttributeInteractionInfo); - Map readProxyDiscoveryAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyDiscoveryAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ProxyDiscoveryCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyDiscoveryClusterAttributeListAttributeCallback(), - readProxyDiscoveryAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readProxyDiscoveryAttributeListAttributeInteractionInfo); - Map readProxyDiscoveryFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyDiscoveryFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readProxyDiscoveryFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readProxyDiscoveryFeatureMapAttributeInteractionInfo); - Map readProxyDiscoveryClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyDiscoveryClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readProxyDiscoveryClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readProxyDiscoveryClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readProxyValidInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readProxyValidGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyValidGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ProxyValidCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyValidClusterGeneratedCommandListAttributeCallback(), - readProxyValidGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readProxyValidGeneratedCommandListAttributeInteractionInfo); - Map readProxyValidAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyValidAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ProxyValidCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedProxyValidClusterAcceptedCommandListAttributeCallback(), - readProxyValidAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readProxyValidAcceptedCommandListAttributeInteractionInfo); - Map readProxyValidEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyValidEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster) - .readEventListAttribute( - (ChipClusters.ProxyValidCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedProxyValidClusterEventListAttributeCallback(), - readProxyValidEventListCommandParams); - result.put("readEventListAttribute", readProxyValidEventListAttributeInteractionInfo); - Map readProxyValidAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyValidAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ProxyValidCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedProxyValidClusterAttributeListAttributeCallback(), - readProxyValidAttributeListCommandParams); - result.put("readAttributeListAttribute", readProxyValidAttributeListAttributeInteractionInfo); - Map readProxyValidFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyValidFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readProxyValidFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readProxyValidFeatureMapAttributeInteractionInfo); - Map readProxyValidClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readProxyValidClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readProxyValidClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readProxyValidClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBooleanStateInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBooleanStateStateValueCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams); - result.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BooleanStateCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBooleanStateClusterGeneratedCommandListAttributeCallback(), - readBooleanStateGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBooleanStateGeneratedCommandListAttributeInteractionInfo); - Map readBooleanStateAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BooleanStateCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBooleanStateClusterAcceptedCommandListAttributeCallback(), - readBooleanStateAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readBooleanStateAcceptedCommandListAttributeInteractionInfo); - Map readBooleanStateEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readEventListAttribute( - (ChipClusters.BooleanStateCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterEventListAttributeCallback(), - readBooleanStateEventListCommandParams); - result.put("readEventListAttribute", readBooleanStateEventListAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams); - result.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBooleanStateFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readBooleanStateFeatureMapAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readIcdManagementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readIcdManagementIdleModeIntervalCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementIdleModeIntervalAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readIdleModeIntervalAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementIdleModeIntervalCommandParams); - result.put( - "readIdleModeIntervalAttribute", readIcdManagementIdleModeIntervalAttributeInteractionInfo); - Map readIcdManagementActiveModeIntervalCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementActiveModeIntervalAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readActiveModeIntervalAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementActiveModeIntervalCommandParams); - result.put( - "readActiveModeIntervalAttribute", - readIcdManagementActiveModeIntervalAttributeInteractionInfo); - Map readIcdManagementActiveModeThresholdCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementActiveModeThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readActiveModeThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIcdManagementActiveModeThresholdCommandParams); - result.put( - "readActiveModeThresholdAttribute", - readIcdManagementActiveModeThresholdAttributeInteractionInfo); - Map readIcdManagementRegisteredClientsCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementRegisteredClientsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readRegisteredClientsAttribute( - (ChipClusters.IcdManagementCluster.RegisteredClientsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIcdManagementClusterRegisteredClientsAttributeCallback(), - readIcdManagementRegisteredClientsCommandParams); - result.put( - "readRegisteredClientsAttribute", - readIcdManagementRegisteredClientsAttributeInteractionInfo); - Map readIcdManagementICDCounterCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementICDCounterAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readICDCounterAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementICDCounterCommandParams); - result.put("readICDCounterAttribute", readIcdManagementICDCounterAttributeInteractionInfo); - Map readIcdManagementClientsSupportedPerFabricCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readClientsSupportedPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIcdManagementClientsSupportedPerFabricCommandParams); - result.put( - "readClientsSupportedPerFabricAttribute", - readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo); - Map readIcdManagementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.IcdManagementCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIcdManagementClusterGeneratedCommandListAttributeCallback(), - readIcdManagementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readIcdManagementGeneratedCommandListAttributeInteractionInfo); - Map readIcdManagementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.IcdManagementCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIcdManagementClusterAcceptedCommandListAttributeCallback(), - readIcdManagementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readIcdManagementAcceptedCommandListAttributeInteractionInfo); - Map readIcdManagementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readEventListAttribute( - (ChipClusters.IcdManagementCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIcdManagementClusterEventListAttributeCallback(), - readIcdManagementEventListCommandParams); - result.put("readEventListAttribute", readIcdManagementEventListAttributeInteractionInfo); - Map readIcdManagementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IcdManagementCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIcdManagementClusterAttributeListAttributeCallback(), - readIcdManagementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readIcdManagementAttributeListAttributeInteractionInfo); - Map readIcdManagementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readIcdManagementFeatureMapAttributeInteractionInfo); - Map readIcdManagementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIcdManagementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIcdManagementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readIcdManagementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readModeSelectInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readModeSelectDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams); - result.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectStandardNamespaceCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectStandardNamespaceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readStandardNamespaceAttribute( - (ChipClusters.ModeSelectCluster.StandardNamespaceAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedModeSelectClusterStandardNamespaceAttributeCallback(), - readModeSelectStandardNamespaceCommandParams); - result.put( - "readStandardNamespaceAttribute", readModeSelectStandardNamespaceAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readSupportedModesAttribute( - (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams); - result.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectCurrentModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams); - result.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readStartUpModeAttribute( - (ChipClusters.ModeSelectCluster.StartUpModeAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterStartUpModeAttributeCallback(), - readModeSelectStartUpModeCommandParams); - result.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readOnModeAttribute( - (ChipClusters.ModeSelectCluster.OnModeAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterOnModeAttributeCallback(), - readModeSelectOnModeCommandParams); - result.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ModeSelectCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedModeSelectClusterGeneratedCommandListAttributeCallback(), - readModeSelectGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readModeSelectGeneratedCommandListAttributeInteractionInfo); - Map readModeSelectAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ModeSelectCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedModeSelectClusterAcceptedCommandListAttributeCallback(), - readModeSelectAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readModeSelectAcceptedCommandListAttributeInteractionInfo); - Map readModeSelectEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readEventListAttribute( - (ChipClusters.ModeSelectCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterEventListAttributeCallback(), - readModeSelectEventListCommandParams); - result.put("readEventListAttribute", readModeSelectEventListAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams); - result.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readModeSelectFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readModeSelectFeatureMapAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readTemperatureControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readTemperatureControlTemperatureSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlTemperatureSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readTemperatureSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlTemperatureSetpointCommandParams); - result.put( - "readTemperatureSetpointAttribute", - readTemperatureControlTemperatureSetpointAttributeInteractionInfo); - Map readTemperatureControlMinTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlMinTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readMinTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlMinTemperatureCommandParams); - result.put( - "readMinTemperatureAttribute", - readTemperatureControlMinTemperatureAttributeInteractionInfo); - Map readTemperatureControlMaxTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlMaxTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readMaxTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlMaxTemperatureCommandParams); - result.put( - "readMaxTemperatureAttribute", - readTemperatureControlMaxTemperatureAttributeInteractionInfo); - Map readTemperatureControlStepCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlStepAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readStepAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlStepCommandParams); - result.put("readStepAttribute", readTemperatureControlStepAttributeInteractionInfo); - Map - readTemperatureControlCurrentTemperatureLevelIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readCurrentTemperatureLevelIndexAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlCurrentTemperatureLevelIndexCommandParams); - result.put( - "readCurrentTemperatureLevelIndexAttribute", - readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo); - Map - readTemperatureControlSupportedTemperatureLevelsCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readSupportedTemperatureLevelsAttribute( - (ChipClusters.TemperatureControlCluster - .SupportedTemperatureLevelsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureControlClusterSupportedTemperatureLevelsAttributeCallback(), - readTemperatureControlSupportedTemperatureLevelsCommandParams); - result.put( - "readSupportedTemperatureLevelsAttribute", - readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo); - Map readTemperatureControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.TemperatureControlCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureControlClusterGeneratedCommandListAttributeCallback(), - readTemperatureControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readTemperatureControlGeneratedCommandListAttributeInteractionInfo); - Map readTemperatureControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.TemperatureControlCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureControlClusterAcceptedCommandListAttributeCallback(), - readTemperatureControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readTemperatureControlAcceptedCommandListAttributeInteractionInfo); - Map readTemperatureControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.TemperatureControlCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureControlClusterEventListAttributeCallback(), - readTemperatureControlEventListCommandParams); - result.put("readEventListAttribute", readTemperatureControlEventListAttributeInteractionInfo); - Map readTemperatureControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TemperatureControlCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureControlClusterAttributeListAttributeCallback(), - readTemperatureControlAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readTemperatureControlAttributeListAttributeInteractionInfo); - Map readTemperatureControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTemperatureControlFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readTemperatureControlFeatureMapAttributeInteractionInfo); - Map readTemperatureControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readTemperatureControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readRefrigeratorAlarmInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readRefrigeratorAlarmMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readMaskAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmMaskCommandParams); - result.put("readMaskAttribute", readRefrigeratorAlarmMaskAttributeInteractionInfo); - Map readRefrigeratorAlarmLatchCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmLatchAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readLatchAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmLatchCommandParams); - result.put("readLatchAttribute", readRefrigeratorAlarmLatchAttributeInteractionInfo); - Map readRefrigeratorAlarmStateCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readStateAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmStateCommandParams); - result.put("readStateAttribute", readRefrigeratorAlarmStateAttributeInteractionInfo); - Map readRefrigeratorAlarmGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRefrigeratorAlarmClusterGeneratedCommandListAttributeCallback(), - readRefrigeratorAlarmGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo); - Map readRefrigeratorAlarmAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRefrigeratorAlarmClusterAcceptedCommandListAttributeCallback(), - readRefrigeratorAlarmAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo); - Map readRefrigeratorAlarmEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readEventListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRefrigeratorAlarmClusterEventListAttributeCallback(), - readRefrigeratorAlarmEventListCommandParams); - result.put("readEventListAttribute", readRefrigeratorAlarmEventListAttributeInteractionInfo); - Map readRefrigeratorAlarmAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRefrigeratorAlarmClusterAttributeListAttributeCallback(), - readRefrigeratorAlarmAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readRefrigeratorAlarmAttributeListAttributeInteractionInfo); - Map readRefrigeratorAlarmFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readRefrigeratorAlarmFeatureMapAttributeInteractionInfo); - Map readRefrigeratorAlarmClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRefrigeratorAlarmClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readAirQualityInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readAirQualityAirQualityCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityAirQualityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readAirQualityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAirQualityAirQualityCommandParams); - result.put("readAirQualityAttribute", readAirQualityAirQualityAttributeInteractionInfo); - Map readAirQualityGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.AirQualityCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAirQualityClusterGeneratedCommandListAttributeCallback(), - readAirQualityGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readAirQualityGeneratedCommandListAttributeInteractionInfo); - Map readAirQualityAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.AirQualityCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAirQualityClusterAcceptedCommandListAttributeCallback(), - readAirQualityAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readAirQualityAcceptedCommandListAttributeInteractionInfo); - Map readAirQualityEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readEventListAttribute( - (ChipClusters.AirQualityCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAirQualityClusterEventListAttributeCallback(), - readAirQualityEventListCommandParams); - result.put("readEventListAttribute", readAirQualityEventListAttributeInteractionInfo); - Map readAirQualityAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AirQualityCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAirQualityClusterAttributeListAttributeCallback(), - readAirQualityAttributeListCommandParams); - result.put("readAttributeListAttribute", readAirQualityAttributeListAttributeInteractionInfo); - Map readAirQualityFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAirQualityFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readAirQualityFeatureMapAttributeInteractionInfo); - Map readAirQualityClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAirQualityClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAirQualityClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readAirQualityClusterRevisionAttributeInteractionInfo); - - 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 readDishwasherAlarmInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readDishwasherAlarmMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readMaskAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmMaskCommandParams); - result.put("readMaskAttribute", readDishwasherAlarmMaskAttributeInteractionInfo); - Map readDishwasherAlarmLatchCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmLatchAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readLatchAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmLatchCommandParams); - result.put("readLatchAttribute", readDishwasherAlarmLatchAttributeInteractionInfo); - Map readDishwasherAlarmStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readStateAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmStateCommandParams); - result.put("readStateAttribute", readDishwasherAlarmStateAttributeInteractionInfo); - Map readDishwasherAlarmGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.DishwasherAlarmCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDishwasherAlarmClusterGeneratedCommandListAttributeCallback(), - readDishwasherAlarmGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo); - Map readDishwasherAlarmAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.DishwasherAlarmCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDishwasherAlarmClusterAcceptedCommandListAttributeCallback(), - readDishwasherAlarmAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo); - Map readDishwasherAlarmEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readEventListAttribute( - (ChipClusters.DishwasherAlarmCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedDishwasherAlarmClusterEventListAttributeCallback(), - readDishwasherAlarmEventListCommandParams); - result.put("readEventListAttribute", readDishwasherAlarmEventListAttributeInteractionInfo); - Map readDishwasherAlarmAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DishwasherAlarmCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDishwasherAlarmClusterAttributeListAttributeCallback(), - readDishwasherAlarmAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readDishwasherAlarmAttributeListAttributeInteractionInfo); - Map readDishwasherAlarmFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readDishwasherAlarmFeatureMapAttributeInteractionInfo); - Map readDishwasherAlarmClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDishwasherAlarmClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDishwasherAlarmClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readDishwasherAlarmClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readHepaFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readHepaFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringConditionCommandParams); - result.put("readConditionAttribute", readHepaFilterMonitoringConditionAttributeInteractionInfo); - Map readHepaFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readHepaFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readHepaFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readHepaFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readHepaFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.HepaFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedHepaFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readHepaFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readHepaFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.HepaFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedHepaFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readHepaFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readHepaFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.HepaFilterMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedHepaFilterMonitoringClusterEventListAttributeCallback(), - readHepaFilterMonitoringEventListCommandParams); - result.put("readEventListAttribute", readHepaFilterMonitoringEventListAttributeInteractionInfo); - Map readHepaFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.HepaFilterMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedHepaFilterMonitoringClusterAttributeListAttributeCallback(), - readHepaFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readHepaFilterMonitoringAttributeListAttributeInteractionInfo); - Map readHepaFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readHepaFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readHepaFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readHepaFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readActivatedCarbonFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readActivatedCarbonFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", - readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo - readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo - readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedActivatedCarbonFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedActivatedCarbonFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster - .EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedActivatedCarbonFilterMonitoringClusterEventListAttributeCallback(), - readActivatedCarbonFilterMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", - readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedActivatedCarbonFilterMonitoringClusterAttributeListAttributeCallback(), - readActivatedCarbonFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readActivatedCarbonFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo); - Map - readActivatedCarbonFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readCeramicFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readCeramicFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", readCeramicFilterMonitoringConditionAttributeInteractionInfo); - Map readCeramicFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readCeramicFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readCeramicFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readCeramicFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readCeramicFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedCeramicFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readCeramicFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readCeramicFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedCeramicFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readCeramicFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readCeramicFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedCeramicFilterMonitoringClusterEventListAttributeCallback(), - readCeramicFilterMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", readCeramicFilterMonitoringEventListAttributeInteractionInfo); - Map readCeramicFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedCeramicFilterMonitoringClusterAttributeListAttributeCallback(), - readCeramicFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readCeramicFilterMonitoringAttributeListAttributeInteractionInfo); - Map readCeramicFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readCeramicFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readCeramicFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readElectrostaticFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readElectrostaticFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", - readElectrostaticFilterMonitoringConditionAttributeInteractionInfo); - Map - readElectrostaticFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map - readElectrostaticFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map - readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map - readElectrostaticFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectrostaticFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readElectrostaticFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map - readElectrostaticFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectrostaticFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readElectrostaticFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectrostaticFilterMonitoringClusterEventListAttributeCallback(), - readElectrostaticFilterMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", - readElectrostaticFilterMonitoringEventListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectrostaticFilterMonitoringClusterAttributeListAttributeCallback(), - readElectrostaticFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectrostaticFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo); - Map - readElectrostaticFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readUvFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readUvFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringConditionCommandParams); - result.put("readConditionAttribute", readUvFilterMonitoringConditionAttributeInteractionInfo); - Map readUvFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readUvFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readUvFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readUvFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUvFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readUvFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.UvFilterMonitoringCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUvFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readUvFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readUvFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.UvFilterMonitoringCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUvFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readUvFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readUvFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.UvFilterMonitoringCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUvFilterMonitoringClusterEventListAttributeCallback(), - readUvFilterMonitoringEventListCommandParams); - result.put("readEventListAttribute", readUvFilterMonitoringEventListAttributeInteractionInfo); - Map readUvFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.UvFilterMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUvFilterMonitoringClusterAttributeListAttributeCallback(), - readUvFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readUvFilterMonitoringAttributeListAttributeInteractionInfo); - Map readUvFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUvFilterMonitoringFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readUvFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readUvFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readUvFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readIonizingFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readIonizingFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", readIonizingFilterMonitoringConditionAttributeInteractionInfo); - Map - readIonizingFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readIonizingFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readIonizingFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readIonizingFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map - readIonizingFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIonizingFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readIonizingFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readIonizingFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIonizingFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readIonizingFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readIonizingFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIonizingFilterMonitoringClusterEventListAttributeCallback(), - readIonizingFilterMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", readIonizingFilterMonitoringEventListAttributeInteractionInfo); - Map readIonizingFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIonizingFilterMonitoringClusterAttributeListAttributeCallback(), - readIonizingFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readIonizingFilterMonitoringAttributeListAttributeInteractionInfo); - Map readIonizingFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIonizingFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readIonizingFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readZeoliteFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readZeoliteFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", readZeoliteFilterMonitoringConditionAttributeInteractionInfo); - Map readZeoliteFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readZeoliteFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readZeoliteFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readZeoliteFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readZeoliteFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedZeoliteFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readZeoliteFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedZeoliteFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readZeoliteFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedZeoliteFilterMonitoringClusterEventListAttributeCallback(), - readZeoliteFilterMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", readZeoliteFilterMonitoringEventListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedZeoliteFilterMonitoringClusterAttributeListAttributeCallback(), - readZeoliteFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readZeoliteFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readZeoliteFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOzoneFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readOzoneFilterMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", readOzoneFilterMonitoringConditionAttributeInteractionInfo); - Map readOzoneFilterMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readOzoneFilterMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readOzoneFilterMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOzoneFilterMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readOzoneFilterMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOzoneFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readOzoneFilterMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readOzoneFilterMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOzoneFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readOzoneFilterMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readOzoneFilterMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOzoneFilterMonitoringClusterEventListAttributeCallback(), - readOzoneFilterMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", readOzoneFilterMonitoringEventListAttributeInteractionInfo); - Map readOzoneFilterMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOzoneFilterMonitoringClusterAttributeListAttributeCallback(), - readOzoneFilterMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readOzoneFilterMonitoringAttributeListAttributeInteractionInfo); - Map readOzoneFilterMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOzoneFilterMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readOzoneFilterMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readWaterTankMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readWaterTankMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringConditionCommandParams); - result.put("readConditionAttribute", readWaterTankMonitoringConditionAttributeInteractionInfo); - Map readWaterTankMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo); - Map readWaterTankMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readWaterTankMonitoringChangeIndicationAttributeInteractionInfo); - Map readWaterTankMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readWaterTankMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readWaterTankMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.WaterTankMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWaterTankMonitoringClusterGeneratedCommandListAttributeCallback(), - readWaterTankMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readWaterTankMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.WaterTankMonitoringCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWaterTankMonitoringClusterAcceptedCommandListAttributeCallback(), - readWaterTankMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readWaterTankMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.WaterTankMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWaterTankMonitoringClusterEventListAttributeCallback(), - readWaterTankMonitoringEventListCommandParams); - result.put("readEventListAttribute", readWaterTankMonitoringEventListAttributeInteractionInfo); - Map readWaterTankMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WaterTankMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWaterTankMonitoringClusterAttributeListAttributeCallback(), - readWaterTankMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readWaterTankMonitoringAttributeListAttributeInteractionInfo); - Map readWaterTankMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWaterTankMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readWaterTankMonitoringFeatureMapAttributeInteractionInfo); - Map readWaterTankMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readWaterTankMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readFuelTankMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readFuelTankMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringConditionCommandParams); - result.put("readConditionAttribute", readFuelTankMonitoringConditionAttributeInteractionInfo); - Map readFuelTankMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo); - Map readFuelTankMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readFuelTankMonitoringChangeIndicationAttributeInteractionInfo); - Map readFuelTankMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readFuelTankMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readFuelTankMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.FuelTankMonitoringCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFuelTankMonitoringClusterGeneratedCommandListAttributeCallback(), - readFuelTankMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readFuelTankMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.FuelTankMonitoringCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFuelTankMonitoringClusterAcceptedCommandListAttributeCallback(), - readFuelTankMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readFuelTankMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.FuelTankMonitoringCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFuelTankMonitoringClusterEventListAttributeCallback(), - readFuelTankMonitoringEventListCommandParams); - result.put("readEventListAttribute", readFuelTankMonitoringEventListAttributeInteractionInfo); - Map readFuelTankMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FuelTankMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFuelTankMonitoringClusterAttributeListAttributeCallback(), - readFuelTankMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readFuelTankMonitoringAttributeListAttributeInteractionInfo); - Map readFuelTankMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFuelTankMonitoringFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readFuelTankMonitoringFeatureMapAttributeInteractionInfo); - Map readFuelTankMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readFuelTankMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readInkCartridgeMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readInkCartridgeMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", readInkCartridgeMonitoringConditionAttributeInteractionInfo); - Map readInkCartridgeMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); - Map readInkCartridgeMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo); - Map readInkCartridgeMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readInkCartridgeMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readInkCartridgeMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedInkCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), - readInkCartridgeMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readInkCartridgeMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedInkCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), - readInkCartridgeMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readInkCartridgeMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedInkCartridgeMonitoringClusterEventListAttributeCallback(), - readInkCartridgeMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", readInkCartridgeMonitoringEventListAttributeInteractionInfo); - Map readInkCartridgeMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedInkCartridgeMonitoringClusterAttributeListAttributeCallback(), - readInkCartridgeMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readInkCartridgeMonitoringAttributeListAttributeInteractionInfo); - Map readInkCartridgeMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readInkCartridgeMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo); - Map readInkCartridgeMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readTonerCartridgeMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readTonerCartridgeMonitoringConditionCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringConditionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringConditionCommandParams); - result.put( - "readConditionAttribute", readTonerCartridgeMonitoringConditionAttributeInteractionInfo); - Map - readTonerCartridgeMonitoringDegradationDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringDegradationDirectionCommandParams); - result.put( - "readDegradationDirectionAttribute", - readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); - Map readTonerCartridgeMonitoringChangeIndicationCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringChangeIndicationCommandParams); - result.put( - "readChangeIndicationAttribute", - readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo); - Map readTonerCartridgeMonitoringInPlaceIndicatorCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTonerCartridgeMonitoringInPlaceIndicatorCommandParams); - result.put( - "readInPlaceIndicatorAttribute", - readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map - readTonerCartridgeMonitoringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTonerCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), - readTonerCartridgeMonitoringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTonerCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), - readTonerCartridgeMonitoringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readEventListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTonerCartridgeMonitoringClusterEventListAttributeCallback(), - readTonerCartridgeMonitoringEventListCommandParams); - result.put( - "readEventListAttribute", readTonerCartridgeMonitoringEventListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTonerCartridgeMonitoringClusterAttributeListAttributeCallback(), - readTonerCartridgeMonitoringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTonerCartridgeMonitoringFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo); - Map readTonerCartridgeMonitoringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readDoorLockInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readDoorLockLockStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLockStateAttribute( - (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterLockStateAttributeCallback(), - readDoorLockLockStateCommandParams); - result.put("readLockStateAttribute", readDoorLockLockStateAttributeInteractionInfo); - Map readDoorLockLockTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLockTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLockTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockTypeCommandParams); - result.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readActuatorEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockActuatorEnabledCommandParams); - result.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readDoorStateAttribute( - (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterDoorStateAttributeCallback(), - readDoorLockDoorStateCommandParams); - result.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockDoorOpenEventsCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockDoorOpenEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readDoorOpenEventsAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockDoorOpenEventsCommandParams); - result.put("readDoorOpenEventsAttribute", readDoorLockDoorOpenEventsAttributeInteractionInfo); - Map readDoorLockDoorClosedEventsCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockDoorClosedEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readDoorClosedEventsAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockDoorClosedEventsCommandParams); - result.put( - "readDoorClosedEventsAttribute", readDoorLockDoorClosedEventsAttributeInteractionInfo); - Map readDoorLockOpenPeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockOpenPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readOpenPeriodAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockOpenPeriodCommandParams); - result.put("readOpenPeriodAttribute", readDoorLockOpenPeriodAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfTotalUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams); - result.put( - "readNumberOfTotalUsersSupportedAttribute", - readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo); - Map readDoorLockNumberOfPINUsersSupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfPINUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfPINUsersSupportedCommandParams); - result.put( - "readNumberOfPINUsersSupportedAttribute", - readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo); - Map readDoorLockNumberOfRFIDUsersSupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfRFIDUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfRFIDUsersSupportedCommandParams); - result.put( - "readNumberOfRFIDUsersSupportedAttribute", - readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo); - Map - readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams); - result.put( - "readNumberOfWeekDaySchedulesSupportedPerUserAttribute", - readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map - readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfYearDaySchedulesSupportedPerUserAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams); - result.put( - "readNumberOfYearDaySchedulesSupportedPerUserAttribute", - readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockNumberOfHolidaySchedulesSupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfHolidaySchedulesSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfHolidaySchedulesSupportedCommandParams); - result.put( - "readNumberOfHolidaySchedulesSupportedAttribute", - readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams); - result.put( - "readMaxPINCodeLengthAttribute", readDoorLockMaxPINCodeLengthAttributeInteractionInfo); - Map readDoorLockMinPINCodeLengthCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockMinPINCodeLengthAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readMinPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMinPINCodeLengthCommandParams); - result.put( - "readMinPINCodeLengthAttribute", readDoorLockMinPINCodeLengthAttributeInteractionInfo); - Map readDoorLockMaxRFIDCodeLengthCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readMaxRFIDCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxRFIDCodeLengthCommandParams); - result.put( - "readMaxRFIDCodeLengthAttribute", readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockMinRFIDCodeLengthCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockMinRFIDCodeLengthAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readMinRFIDCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMinRFIDCodeLengthCommandParams); - result.put( - "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockCredentialRulesSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockCredentialRulesSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readCredentialRulesSupportAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockCredentialRulesSupportCommandParams); - result.put( - "readCredentialRulesSupportAttribute", - readDoorLockCredentialRulesSupportAttributeInteractionInfo); - Map readDoorLockNumberOfCredentialsSupportedPerUserCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfCredentialsSupportedPerUserAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfCredentialsSupportedPerUserCommandParams); - result.put( - "readNumberOfCredentialsSupportedPerUserAttribute", - readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams); - result.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockLEDSettingsCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLEDSettingsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLEDSettingsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLEDSettingsCommandParams); - result.put("readLEDSettingsAttribute", readDoorLockLEDSettingsAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams); - result.put("readAutoRelockTimeAttribute", readDoorLockAutoRelockTimeAttributeInteractionInfo); - Map readDoorLockSoundVolumeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockSoundVolumeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readSoundVolumeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockSoundVolumeCommandParams); - result.put("readSoundVolumeAttribute", readDoorLockSoundVolumeAttributeInteractionInfo); - Map readDoorLockOperatingModeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockOperatingModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readOperatingModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockOperatingModeCommandParams); - result.put("readOperatingModeAttribute", readDoorLockOperatingModeAttributeInteractionInfo); - Map readDoorLockSupportedOperatingModesCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockSupportedOperatingModesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readSupportedOperatingModesAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockSupportedOperatingModesCommandParams); - result.put( - "readSupportedOperatingModesAttribute", - readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockDefaultConfigurationRegisterCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readDefaultConfigurationRegisterAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDefaultConfigurationRegisterCommandParams); - result.put( - "readDefaultConfigurationRegisterAttribute", - readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo); - Map readDoorLockEnableLocalProgrammingCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnableLocalProgrammingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnableLocalProgrammingAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableLocalProgrammingCommandParams); - result.put( - "readEnableLocalProgrammingAttribute", - readDoorLockEnableLocalProgrammingAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnableOneTouchLockingAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams); - result.put( - "readEnableOneTouchLockingAttribute", - readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnableInsideStatusLEDCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnableInsideStatusLEDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnableInsideStatusLEDAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableInsideStatusLEDCommandParams); - result.put( - "readEnableInsideStatusLEDAttribute", - readDoorLockEnableInsideStatusLEDAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnablePrivacyModeButtonAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams); - result.put( - "readEnablePrivacyModeButtonAttribute", - readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockLocalProgrammingFeaturesCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLocalProgrammingFeaturesAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLocalProgrammingFeaturesCommandParams); - result.put( - "readLocalProgrammingFeaturesAttribute", - readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readWrongCodeEntryLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams); - result.put( - "readWrongCodeEntryLimitAttribute", - readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockUserCodeTemporaryDisableTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readUserCodeTemporaryDisableTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockUserCodeTemporaryDisableTimeCommandParams); - result.put( - "readUserCodeTemporaryDisableTimeAttribute", - readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); - Map readDoorLockSendPINOverTheAirCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockSendPINOverTheAirAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readSendPINOverTheAirAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockSendPINOverTheAirCommandParams); - result.put( - "readSendPINOverTheAirAttribute", readDoorLockSendPINOverTheAirAttributeInteractionInfo); - Map readDoorLockRequirePINforRemoteOperationCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readRequirePINforRemoteOperationAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockRequirePINforRemoteOperationCommandParams); - result.put( - "readRequirePINforRemoteOperationAttribute", - readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); - Map readDoorLockExpiringUserTimeoutCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockExpiringUserTimeoutAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readExpiringUserTimeoutAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockExpiringUserTimeoutCommandParams); - result.put( - "readExpiringUserTimeoutAttribute", - readDoorLockExpiringUserTimeoutAttributeInteractionInfo); - Map readDoorLockGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.DoorLockCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDoorLockClusterGeneratedCommandListAttributeCallback(), - readDoorLockGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readDoorLockGeneratedCommandListAttributeInteractionInfo); - Map readDoorLockAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.DoorLockCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDoorLockClusterAcceptedCommandListAttributeCallback(), - readDoorLockAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readDoorLockAcceptedCommandListAttributeInteractionInfo); - Map readDoorLockEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEventListAttribute( - (ChipClusters.DoorLockCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterEventListAttributeCallback(), - readDoorLockEventListCommandParams); - result.put("readEventListAttribute", readDoorLockEventListAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams); - result.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readDoorLockFeatureMapAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readWindowCoveringInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readWindowCoveringTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams); - result.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringPhysicalClosedLimitLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readPhysicalClosedLimitLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringPhysicalClosedLimitLiftCommandParams); - result.put( - "readPhysicalClosedLimitLiftAttribute", - readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo); - Map readWindowCoveringPhysicalClosedLimitTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readPhysicalClosedLimitTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringPhysicalClosedLimitTiltCommandParams); - result.put( - "readPhysicalClosedLimitTiltAttribute", - readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterCurrentPositionLiftAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams); - result.put( - "readCurrentPositionLiftAttribute", - readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterCurrentPositionTiltAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams); - result.put( - "readCurrentPositionTiltAttribute", - readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringNumberOfActuationsLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readNumberOfActuationsLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringNumberOfActuationsLiftCommandParams); - result.put( - "readNumberOfActuationsLiftAttribute", - readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo); - Map readWindowCoveringNumberOfActuationsTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readNumberOfActuationsTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringNumberOfActuationsTiltCommandParams); - result.put( - "readNumberOfActuationsTiltAttribute", - readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams); - result.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftPercentageAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionLiftPercentageAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterCurrentPositionLiftPercentageAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams); - result.put( - "readCurrentPositionLiftPercentageAttribute", - readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltPercentageAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionTiltPercentageAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterCurrentPositionTiltPercentageAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams); - result.put( - "readCurrentPositionTiltPercentageAttribute", - readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo); - Map readWindowCoveringOperationalStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringOperationalStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readOperationalStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringOperationalStatusCommandParams); - result.put( - "readOperationalStatusAttribute", - readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map - readWindowCoveringTargetPositionLiftPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTargetPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .TargetPositionLiftPercent100thsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterTargetPositionLiftPercent100thsAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams); - result.put( - "readTargetPositionLiftPercent100thsAttribute", - readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map - readWindowCoveringTargetPositionTiltPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTargetPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .TargetPositionTiltPercent100thsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterTargetPositionTiltPercent100thsAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams); - result.put( - "readTargetPositionTiltPercent100thsAttribute", - readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo); - Map readWindowCoveringEndProductTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringEndProductTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readEndProductTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringEndProductTypeCommandParams); - result.put( - "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionLiftPercent100thsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterCurrentPositionLiftPercent100thsAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); - result.put( - "readCurrentPositionLiftPercent100thsAttribute", - readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionTiltPercent100thsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterCurrentPositionTiltPercent100thsAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); - result.put( - "readCurrentPositionTiltPercent100thsAttribute", - readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo); - Map readWindowCoveringInstalledOpenLimitLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readInstalledOpenLimitLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledOpenLimitLiftCommandParams); - result.put( - "readInstalledOpenLimitLiftAttribute", - readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo); - Map readWindowCoveringInstalledClosedLimitLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readInstalledClosedLimitLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledClosedLimitLiftCommandParams); - result.put( - "readInstalledClosedLimitLiftAttribute", - readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo); - Map readWindowCoveringInstalledOpenLimitTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readInstalledOpenLimitTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledOpenLimitTiltCommandParams); - result.put( - "readInstalledOpenLimitTiltAttribute", - readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo); - Map readWindowCoveringInstalledClosedLimitTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readInstalledClosedLimitTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledClosedLimitTiltCommandParams); - result.put( - "readInstalledClosedLimitTiltAttribute", - readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo); - Map readWindowCoveringModeCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringModeCommandParams); - result.put("readModeAttribute", readWindowCoveringModeAttributeInteractionInfo); - Map readWindowCoveringSafetyStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringSafetyStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readSafetyStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringSafetyStatusCommandParams); - result.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.WindowCoveringCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterGeneratedCommandListAttributeCallback(), - readWindowCoveringGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readWindowCoveringGeneratedCommandListAttributeInteractionInfo); - Map readWindowCoveringAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.WindowCoveringCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterAcceptedCommandListAttributeCallback(), - readWindowCoveringAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readWindowCoveringAcceptedCommandListAttributeInteractionInfo); - Map readWindowCoveringEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readEventListAttribute( - (ChipClusters.WindowCoveringCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterEventListAttributeCallback(), - readWindowCoveringEventListCommandParams); - result.put("readEventListAttribute", readWindowCoveringEventListAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWindowCoveringFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readWindowCoveringFeatureMapAttributeInteractionInfo); - Map readWindowCoveringClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBarrierControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBarrierControlBarrierMovingStateCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierMovingStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams); - result.put( - "readBarrierMovingStateAttribute", - readBarrierControlBarrierMovingStateAttributeInteractionInfo); - Map readBarrierControlBarrierSafetyStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierSafetyStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierSafetyStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierSafetyStatusCommandParams); - result.put( - "readBarrierSafetyStatusAttribute", - readBarrierControlBarrierSafetyStatusAttributeInteractionInfo); - Map readBarrierControlBarrierCapabilitiesCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCapabilitiesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierCapabilitiesAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCapabilitiesCommandParams); - result.put( - "readBarrierCapabilitiesAttribute", - readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierOpenEventsCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierOpenEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierOpenEventsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierOpenEventsCommandParams); - result.put( - "readBarrierOpenEventsAttribute", - readBarrierControlBarrierOpenEventsAttributeInteractionInfo); - Map readBarrierControlBarrierCloseEventsCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCloseEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierCloseEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCloseEventsCommandParams); - result.put( - "readBarrierCloseEventsAttribute", - readBarrierControlBarrierCloseEventsAttributeInteractionInfo); - Map readBarrierControlBarrierCommandOpenEventsCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierCommandOpenEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCommandOpenEventsCommandParams); - result.put( - "readBarrierCommandOpenEventsAttribute", - readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); - Map readBarrierControlBarrierCommandCloseEventsCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierCommandCloseEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCommandCloseEventsCommandParams); - result.put( - "readBarrierCommandCloseEventsAttribute", - readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); - Map readBarrierControlBarrierOpenPeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierOpenPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierOpenPeriodAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierOpenPeriodCommandParams); - result.put( - "readBarrierOpenPeriodAttribute", - readBarrierControlBarrierOpenPeriodAttributeInteractionInfo); - Map readBarrierControlBarrierClosePeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierClosePeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierClosePeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierClosePeriodCommandParams); - result.put( - "readBarrierClosePeriodAttribute", - readBarrierControlBarrierClosePeriodAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams); - result.put( - "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BarrierControlCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBarrierControlClusterGeneratedCommandListAttributeCallback(), - readBarrierControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBarrierControlGeneratedCommandListAttributeInteractionInfo); - Map readBarrierControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BarrierControlCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBarrierControlClusterAcceptedCommandListAttributeCallback(), - readBarrierControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readBarrierControlAcceptedCommandListAttributeInteractionInfo); - Map readBarrierControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.BarrierControlCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterEventListAttributeCallback(), - readBarrierControlEventListCommandParams); - result.put("readEventListAttribute", readBarrierControlEventListAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBarrierControlFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readBarrierControlFeatureMapAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readPumpConfigurationAndControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readPumpConfigurationAndControlMaxPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxPressureAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxPressureAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams); - result.put( - "readMaxPressureAttribute", - readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxSpeedAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxSpeedAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams); - result.put( - "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxFlowAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxFlowAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxFlowAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams); - result.put( - "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MinConstPressureAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMinConstPressureAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams); - result.put( - "readMinConstPressureAttribute", - readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MaxConstPressureAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxConstPressureAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams); - result.put( - "readMaxConstPressureAttribute", - readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinCompPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MinCompPressureAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMinCompPressureAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams); - result.put( - "readMinCompPressureAttribute", - readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxCompPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MaxCompPressureAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxCompPressureAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams); - result.put( - "readMaxCompPressureAttribute", - readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MinConstSpeedAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMinConstSpeedAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams); - result.put( - "readMinConstSpeedAttribute", - readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MaxConstSpeedAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxConstSpeedAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams); - result.put( - "readMaxConstSpeedAttribute", - readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstFlowAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MinConstFlowAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMinConstFlowAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams); - result.put( - "readMinConstFlowAttribute", - readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstFlowAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MaxConstFlowAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxConstFlowAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams); - result.put( - "readMaxConstFlowAttribute", - readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstTempAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MinConstTempAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMinConstTempAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams); - result.put( - "readMinConstTempAttribute", - readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstTempAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .MaxConstTempAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterMaxConstTempAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams); - result.put( - "readMaxConstTempAttribute", - readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlPumpStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readPumpStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlPumpStatusCommandParams); - result.put( - "readPumpStatusAttribute", - readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo); - Map - readPumpConfigurationAndControlEffectiveOperationModeCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readEffectiveOperationModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlEffectiveOperationModeCommandParams); - result.put( - "readEffectiveOperationModeAttribute", - readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo); - Map - readPumpConfigurationAndControlEffectiveControlModeCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readEffectiveControlModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlEffectiveControlModeCommandParams); - result.put( - "readEffectiveControlModeAttribute", - readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readCapacityAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.CapacityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterCapacityAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams); - result.put( - "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.SpeedAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterSpeedAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams); - result.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readLifetimeRunningHoursAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .LifetimeRunningHoursAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterLifetimeRunningHoursAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); - result.put( - "readLifetimeRunningHoursAttribute", - readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readPowerAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.PowerAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterPowerAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams); - result.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readLifetimeEnergyConsumedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .LifetimeEnergyConsumedAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterLifetimeEnergyConsumedAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); - result.put( - "readLifetimeEnergyConsumedAttribute", - readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); - Map readPumpConfigurationAndControlOperationModeCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlOperationModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readOperationModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlOperationModeCommandParams); - result.put( - "readOperationModeAttribute", - readPumpConfigurationAndControlOperationModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlControlModeCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlControlModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readControlModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlControlModeCommandParams); - result.put( - "readControlModeAttribute", - readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map - readPumpConfigurationAndControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterGeneratedCommandListAttributeCallback(), - readPumpConfigurationAndControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo); - Map - readPumpConfigurationAndControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterAcceptedCommandListAttributeCallback(), - readPumpConfigurationAndControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo); - Map readPumpConfigurationAndControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterEventListAttributeCallback(), - readPumpConfigurationAndControlEventListCommandParams); - result.put( - "readEventListAttribute", readPumpConfigurationAndControlEventListAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo); - Map readPumpConfigurationAndControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readThermostatInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readThermostatLocalTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readLocalTemperatureAttribute( - (ChipClusters.ThermostatCluster.LocalTemperatureAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterLocalTemperatureAttributeCallback(), - readThermostatLocalTemperatureCommandParams); - result.put( - "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatOutdoorTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOutdoorTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOutdoorTemperatureAttribute( - (ChipClusters.ThermostatCluster.OutdoorTemperatureAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterOutdoorTemperatureAttributeCallback(), - readThermostatOutdoorTemperatureCommandParams); - result.put( - "readOutdoorTemperatureAttribute", - readThermostatOutdoorTemperatureAttributeInteractionInfo); - Map readThermostatOccupancyCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupancyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupancyCommandParams); - result.put("readOccupancyAttribute", readThermostatOccupancyAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAbsMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams); - result.put( - "readAbsMinHeatSetpointLimitAttribute", - readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatAbsMaxHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAbsMaxHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMaxHeatSetpointLimitCommandParams); - result.put( - "readAbsMaxHeatSetpointLimitAttribute", - readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatAbsMinCoolSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAbsMinCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinCoolSetpointLimitCommandParams); - result.put( - "readAbsMinCoolSetpointLimitAttribute", - readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatAbsMaxCoolSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAbsMaxCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMaxCoolSetpointLimitCommandParams); - result.put( - "readAbsMaxCoolSetpointLimitAttribute", - readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatPICoolingDemandCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatPICoolingDemandAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readPICoolingDemandAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatPICoolingDemandCommandParams); - result.put( - "readPICoolingDemandAttribute", readThermostatPICoolingDemandAttributeInteractionInfo); - Map readThermostatPIHeatingDemandCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatPIHeatingDemandAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readPIHeatingDemandAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatPIHeatingDemandCommandParams); - result.put( - "readPIHeatingDemandAttribute", readThermostatPIHeatingDemandAttributeInteractionInfo); - Map readThermostatHVACSystemTypeConfigurationCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readHVACSystemTypeConfigurationAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatHVACSystemTypeConfigurationCommandParams); - result.put( - "readHVACSystemTypeConfigurationAttribute", - readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); - Map readThermostatLocalTemperatureCalibrationCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureCalibrationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readLocalTemperatureCalibrationAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCalibrationCommandParams); - result.put( - "readLocalTemperatureCalibrationAttribute", - readThermostatLocalTemperatureCalibrationAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedCoolingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams); - result.put( - "readOccupiedCoolingSetpointAttribute", - readThermostatOccupiedCoolingSetpointAttributeInteractionInfo); - Map readThermostatOccupiedHeatingSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedHeatingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedHeatingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedHeatingSetpointCommandParams); - result.put( - "readOccupiedHeatingSetpointAttribute", - readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatUnoccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readUnoccupiedCoolingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUnoccupiedCoolingSetpointCommandParams); - result.put( - "readUnoccupiedCoolingSetpointAttribute", - readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); - Map readThermostatUnoccupiedHeatingSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readUnoccupiedHeatingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUnoccupiedHeatingSetpointCommandParams); - result.put( - "readUnoccupiedHeatingSetpointAttribute", - readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams); - result.put( - "readMinHeatSetpointLimitAttribute", - readThermostatMinHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatMaxHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMaxHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMaxHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMaxHeatSetpointLimitCommandParams); - result.put( - "readMaxHeatSetpointLimitAttribute", - readThermostatMaxHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatMinCoolSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMinCoolSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMinCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinCoolSetpointLimitCommandParams); - result.put( - "readMinCoolSetpointLimitAttribute", - readThermostatMinCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatMaxCoolSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMaxCoolSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMaxCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMaxCoolSetpointLimitCommandParams); - result.put( - "readMaxCoolSetpointLimitAttribute", - readThermostatMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatMinSetpointDeadBandCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMinSetpointDeadBandAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMinSetpointDeadBandAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinSetpointDeadBandCommandParams); - result.put( - "readMinSetpointDeadBandAttribute", - readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatRemoteSensingCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatRemoteSensingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readRemoteSensingAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatRemoteSensingCommandParams); - result.put("readRemoteSensingAttribute", readThermostatRemoteSensingAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readControlSequenceOfOperationAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams); - result.put( - "readControlSequenceOfOperationAttribute", - readThermostatControlSequenceOfOperationAttributeInteractionInfo); - Map readThermostatSystemModeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatSystemModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readSystemModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatSystemModeCommandParams); - result.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatThermostatRunningModeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatThermostatRunningModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readThermostatRunningModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatThermostatRunningModeCommandParams); - result.put( - "readThermostatRunningModeAttribute", - readThermostatThermostatRunningModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams); - result.put("readStartOfWeekAttribute", readThermostatStartOfWeekAttributeInteractionInfo); - Map readThermostatNumberOfWeeklyTransitionsCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readNumberOfWeeklyTransitionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatNumberOfWeeklyTransitionsCommandParams); - result.put( - "readNumberOfWeeklyTransitionsAttribute", - readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo); - Map readThermostatNumberOfDailyTransitionsCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatNumberOfDailyTransitionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readNumberOfDailyTransitionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatNumberOfDailyTransitionsCommandParams); - result.put( - "readNumberOfDailyTransitionsAttribute", - readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatTemperatureSetpointHoldCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatTemperatureSetpointHoldAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readTemperatureSetpointHoldAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatTemperatureSetpointHoldCommandParams); - result.put( - "readTemperatureSetpointHoldAttribute", - readThermostatTemperatureSetpointHoldAttributeInteractionInfo); - Map readThermostatTemperatureSetpointHoldDurationCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readTemperatureSetpointHoldDurationAttribute( - (ChipClusters.ThermostatCluster - .TemperatureSetpointHoldDurationAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterTemperatureSetpointHoldDurationAttributeCallback(), - readThermostatTemperatureSetpointHoldDurationCommandParams); - result.put( - "readTemperatureSetpointHoldDurationAttribute", - readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); - Map - readThermostatThermostatProgrammingOperationModeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readThermostatProgrammingOperationModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatThermostatProgrammingOperationModeCommandParams); - result.put( - "readThermostatProgrammingOperationModeAttribute", - readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); - Map readThermostatThermostatRunningStateCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatThermostatRunningStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readThermostatRunningStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatThermostatRunningStateCommandParams); - result.put( - "readThermostatRunningStateAttribute", - readThermostatThermostatRunningStateAttributeInteractionInfo); - Map readThermostatSetpointChangeSourceCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatSetpointChangeSourceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readSetpointChangeSourceAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatSetpointChangeSourceCommandParams); - result.put( - "readSetpointChangeSourceAttribute", - readThermostatSetpointChangeSourceAttributeInteractionInfo); - Map readThermostatSetpointChangeAmountCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatSetpointChangeAmountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readSetpointChangeAmountAttribute( - (ChipClusters.ThermostatCluster.SetpointChangeAmountAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterSetpointChangeAmountAttributeCallback(), - readThermostatSetpointChangeAmountCommandParams); - result.put( - "readSetpointChangeAmountAttribute", - readThermostatSetpointChangeAmountAttributeInteractionInfo); - Map readThermostatSetpointChangeSourceTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readSetpointChangeSourceTimestampAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatSetpointChangeSourceTimestampCommandParams); - result.put( - "readSetpointChangeSourceTimestampAttribute", - readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo); - Map readThermostatOccupiedSetbackCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedSetbackAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedSetbackAttribute( - (ChipClusters.ThermostatCluster.OccupiedSetbackAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackAttributeCallback(), - readThermostatOccupiedSetbackCommandParams); - result.put( - "readOccupiedSetbackAttribute", readThermostatOccupiedSetbackAttributeInteractionInfo); - Map readThermostatOccupiedSetbackMinCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedSetbackMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedSetbackMinAttribute( - (ChipClusters.ThermostatCluster.OccupiedSetbackMinAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterOccupiedSetbackMinAttributeCallback(), - readThermostatOccupiedSetbackMinCommandParams); - result.put( - "readOccupiedSetbackMinAttribute", - readThermostatOccupiedSetbackMinAttributeInteractionInfo); - Map readThermostatOccupiedSetbackMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedSetbackMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedSetbackMaxAttribute( - (ChipClusters.ThermostatCluster.OccupiedSetbackMaxAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterOccupiedSetbackMaxAttributeCallback(), - readThermostatOccupiedSetbackMaxCommandParams); - result.put( - "readOccupiedSetbackMaxAttribute", - readThermostatOccupiedSetbackMaxAttributeInteractionInfo); - Map readThermostatUnoccupiedSetbackCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedSetbackAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readUnoccupiedSetbackAttribute( - (ChipClusters.ThermostatCluster.UnoccupiedSetbackAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterUnoccupiedSetbackAttributeCallback(), - readThermostatUnoccupiedSetbackCommandParams); - result.put( - "readUnoccupiedSetbackAttribute", readThermostatUnoccupiedSetbackAttributeInteractionInfo); - Map readThermostatUnoccupiedSetbackMinCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedSetbackMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readUnoccupiedSetbackMinAttribute( - (ChipClusters.ThermostatCluster.UnoccupiedSetbackMinAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterUnoccupiedSetbackMinAttributeCallback(), - readThermostatUnoccupiedSetbackMinCommandParams); - result.put( - "readUnoccupiedSetbackMinAttribute", - readThermostatUnoccupiedSetbackMinAttributeInteractionInfo); - Map readThermostatUnoccupiedSetbackMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readUnoccupiedSetbackMaxAttribute( - (ChipClusters.ThermostatCluster.UnoccupiedSetbackMaxAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterUnoccupiedSetbackMaxAttributeCallback(), - readThermostatUnoccupiedSetbackMaxCommandParams); - result.put( - "readUnoccupiedSetbackMaxAttribute", - readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo); - Map readThermostatEmergencyHeatDeltaCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatEmergencyHeatDeltaAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readEmergencyHeatDeltaAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatEmergencyHeatDeltaCommandParams); - result.put( - "readEmergencyHeatDeltaAttribute", - readThermostatEmergencyHeatDeltaAttributeInteractionInfo); - Map readThermostatACTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACTypeCommandParams); - result.put("readACTypeAttribute", readThermostatACTypeAttributeInteractionInfo); - Map readThermostatACCapacityCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACCapacityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACCapacityCommandParams); - result.put("readACCapacityAttribute", readThermostatACCapacityAttributeInteractionInfo); - Map readThermostatACRefrigerantTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACRefrigerantTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACRefrigerantTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACRefrigerantTypeCommandParams); - result.put( - "readACRefrigerantTypeAttribute", readThermostatACRefrigerantTypeAttributeInteractionInfo); - Map readThermostatACCompressorTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACCompressorTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACCompressorTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACCompressorTypeCommandParams); - result.put( - "readACCompressorTypeAttribute", readThermostatACCompressorTypeAttributeInteractionInfo); - Map readThermostatACErrorCodeCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACErrorCodeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACErrorCodeAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatACErrorCodeCommandParams); - result.put("readACErrorCodeAttribute", readThermostatACErrorCodeAttributeInteractionInfo); - Map readThermostatACLouverPositionCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACLouverPositionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACLouverPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACLouverPositionCommandParams); - result.put( - "readACLouverPositionAttribute", readThermostatACLouverPositionAttributeInteractionInfo); - Map readThermostatACCoilTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACCoilTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACCoilTemperatureAttribute( - (ChipClusters.ThermostatCluster.ACCoilTemperatureAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterACCoilTemperatureAttributeCallback(), - readThermostatACCoilTemperatureCommandParams); - result.put( - "readACCoilTemperatureAttribute", readThermostatACCoilTemperatureAttributeInteractionInfo); - Map readThermostatACCapacityformatCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatACCapacityformatAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readACCapacityformatAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACCapacityformatCommandParams); - result.put( - "readACCapacityformatAttribute", readThermostatACCapacityformatAttributeInteractionInfo); - Map readThermostatGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ThermostatCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterGeneratedCommandListAttributeCallback(), - readThermostatGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readThermostatGeneratedCommandListAttributeInteractionInfo); - Map readThermostatAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ThermostatCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatClusterAcceptedCommandListAttributeCallback(), - readThermostatAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readThermostatAcceptedCommandListAttributeInteractionInfo); - Map readThermostatEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readEventListAttribute( - (ChipClusters.ThermostatCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterEventListAttributeCallback(), - readThermostatEventListCommandParams); - result.put("readEventListAttribute", readThermostatEventListAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams); - result.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readThermostatFeatureMapAttributeInteractionInfo); - Map readThermostatClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readFanControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readFanControlFanModeCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlFanModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readFanModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlFanModeCommandParams); - result.put("readFanModeAttribute", readFanControlFanModeAttributeInteractionInfo); - Map readFanControlFanModeSequenceCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlFanModeSequenceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readFanModeSequenceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlFanModeSequenceCommandParams); - result.put( - "readFanModeSequenceAttribute", readFanControlFanModeSequenceAttributeInteractionInfo); - Map readFanControlPercentSettingCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlPercentSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readPercentSettingAttribute( - (ChipClusters.FanControlCluster.PercentSettingAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedFanControlClusterPercentSettingAttributeCallback(), - readFanControlPercentSettingCommandParams); - result.put("readPercentSettingAttribute", readFanControlPercentSettingAttributeInteractionInfo); - Map readFanControlPercentCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlPercentCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readPercentCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlPercentCurrentCommandParams); - result.put("readPercentCurrentAttribute", readFanControlPercentCurrentAttributeInteractionInfo); - Map readFanControlSpeedMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlSpeedMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readSpeedMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlSpeedMaxCommandParams); - result.put("readSpeedMaxAttribute", readFanControlSpeedMaxAttributeInteractionInfo); - Map readFanControlSpeedSettingCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlSpeedSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readSpeedSettingAttribute( - (ChipClusters.FanControlCluster.SpeedSettingAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterSpeedSettingAttributeCallback(), - readFanControlSpeedSettingCommandParams); - result.put("readSpeedSettingAttribute", readFanControlSpeedSettingAttributeInteractionInfo); - Map readFanControlSpeedCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlSpeedCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readSpeedCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlSpeedCurrentCommandParams); - result.put("readSpeedCurrentAttribute", readFanControlSpeedCurrentAttributeInteractionInfo); - Map readFanControlRockSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlRockSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readRockSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlRockSupportCommandParams); - result.put("readRockSupportAttribute", readFanControlRockSupportAttributeInteractionInfo); - Map readFanControlRockSettingCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlRockSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readRockSettingAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlRockSettingCommandParams); - result.put("readRockSettingAttribute", readFanControlRockSettingAttributeInteractionInfo); - Map readFanControlWindSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlWindSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readWindSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlWindSupportCommandParams); - result.put("readWindSupportAttribute", readFanControlWindSupportAttributeInteractionInfo); - Map readFanControlWindSettingCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlWindSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readWindSettingAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlWindSettingCommandParams); - result.put("readWindSettingAttribute", readFanControlWindSettingAttributeInteractionInfo); - Map readFanControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.FanControlCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFanControlClusterGeneratedCommandListAttributeCallback(), - readFanControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readFanControlGeneratedCommandListAttributeInteractionInfo); - Map readFanControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.FanControlCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFanControlClusterAcceptedCommandListAttributeCallback(), - readFanControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readFanControlAcceptedCommandListAttributeInteractionInfo); - Map readFanControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.FanControlCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterEventListAttributeCallback(), - readFanControlEventListCommandParams); - result.put("readEventListAttribute", readFanControlEventListAttributeInteractionInfo); - Map readFanControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FanControlCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterAttributeListAttributeCallback(), - readFanControlAttributeListCommandParams); - result.put("readAttributeListAttribute", readFanControlAttributeListAttributeInteractionInfo); - Map readFanControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFanControlFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readFanControlFeatureMapAttributeInteractionInfo); - Map readFanControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFanControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readFanControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map - readThermostatUserInterfaceConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readTemperatureDisplayModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); - result.put( - "readTemperatureDisplayModeAttribute", - readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readKeypadLockoutAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams); - result.put( - "readKeypadLockoutAttribute", - readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readScheduleProgrammingVisibilityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams); - result.put( - "readScheduleProgrammingVisibilityAttribute", - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatUserInterfaceConfigurationClusterGeneratedCommandListAttributeCallback(), - readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatUserInterfaceConfigurationClusterAcceptedCommandListAttributeCallback(), - readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readEventListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster - .EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatUserInterfaceConfigurationClusterEventListAttributeCallback(), - readThermostatUserInterfaceConfigurationEventListCommandParams); - result.put( - "readEventListAttribute", - readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatUserInterfaceConfigurationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readColorControlInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readColorControlCurrentHueCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams); - result.put("readCurrentHueAttribute", readColorControlCurrentHueAttributeInteractionInfo); - Map readColorControlCurrentSaturationCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCurrentSaturationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCurrentSaturationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentSaturationCommandParams); - result.put( - "readCurrentSaturationAttribute", - readColorControlCurrentSaturationAttributeInteractionInfo); - Map readColorControlRemainingTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlRemainingTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readRemainingTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlRemainingTimeCommandParams); - result.put("readRemainingTimeAttribute", readColorControlRemainingTimeAttributeInteractionInfo); - Map readColorControlCurrentXCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCurrentXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCurrentXAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentXCommandParams); - result.put("readCurrentXAttribute", readColorControlCurrentXAttributeInteractionInfo); - Map readColorControlCurrentYCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCurrentYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCurrentYAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentYCommandParams); - result.put("readCurrentYAttribute", readColorControlCurrentYAttributeInteractionInfo); - Map readColorControlDriftCompensationCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlDriftCompensationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readDriftCompensationAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlDriftCompensationCommandParams); - result.put( - "readDriftCompensationAttribute", - readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCompensationTextAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readColorControlCompensationTextCommandParams); - result.put( - "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTemperatureMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureMiredsCommandParams); - result.put( - "readColorTemperatureMiredsAttribute", - readColorControlColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams); - result.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlOptionsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readOptionsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlOptionsCommandParams); - result.put("readOptionsAttribute", readColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readNumberOfPrimariesAttribute( - (ChipClusters.ColorControlCluster.NumberOfPrimariesAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterNumberOfPrimariesAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams); - result.put( - "readNumberOfPrimariesAttribute", - readColorControlNumberOfPrimariesAttributeInteractionInfo); - Map readColorControlPrimary1XCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary1XAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary1XAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1XCommandParams); - result.put("readPrimary1XAttribute", readColorControlPrimary1XAttributeInteractionInfo); - Map readColorControlPrimary1YCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary1YAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary1YAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1YCommandParams); - result.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary1IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary1IntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterPrimary1IntensityAttributeCallback(), - readColorControlPrimary1IntensityCommandParams); - result.put( - "readPrimary1IntensityAttribute", - readColorControlPrimary1IntensityAttributeInteractionInfo); - Map readColorControlPrimary2XCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary2XAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary2XAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2XCommandParams); - result.put("readPrimary2XAttribute", readColorControlPrimary2XAttributeInteractionInfo); - Map readColorControlPrimary2YCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary2YAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary2YAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2YCommandParams); - result.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary2IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary2IntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterPrimary2IntensityAttributeCallback(), - readColorControlPrimary2IntensityCommandParams); - result.put( - "readPrimary2IntensityAttribute", - readColorControlPrimary2IntensityAttributeInteractionInfo); - Map readColorControlPrimary3XCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary3XAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary3XAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3XCommandParams); - result.put("readPrimary3XAttribute", readColorControlPrimary3XAttributeInteractionInfo); - Map readColorControlPrimary3YCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary3YAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary3YAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3YCommandParams); - result.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary3IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary3IntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterPrimary3IntensityAttributeCallback(), - readColorControlPrimary3IntensityCommandParams); - result.put( - "readPrimary3IntensityAttribute", - readColorControlPrimary3IntensityAttributeInteractionInfo); - Map readColorControlPrimary4XCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary4XAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary4XAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4XCommandParams); - result.put("readPrimary4XAttribute", readColorControlPrimary4XAttributeInteractionInfo); - Map readColorControlPrimary4YCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary4YAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary4YAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4YCommandParams); - result.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary4IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary4IntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterPrimary4IntensityAttributeCallback(), - readColorControlPrimary4IntensityCommandParams); - result.put( - "readPrimary4IntensityAttribute", - readColorControlPrimary4IntensityAttributeInteractionInfo); - Map readColorControlPrimary5XCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary5XAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary5XAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5XCommandParams); - result.put("readPrimary5XAttribute", readColorControlPrimary5XAttributeInteractionInfo); - Map readColorControlPrimary5YCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary5YAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary5YAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5YCommandParams); - result.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary5IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary5IntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterPrimary5IntensityAttributeCallback(), - readColorControlPrimary5IntensityCommandParams); - result.put( - "readPrimary5IntensityAttribute", - readColorControlPrimary5IntensityAttributeInteractionInfo); - Map readColorControlPrimary6XCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary6XAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary6XAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6XCommandParams); - result.put("readPrimary6XAttribute", readColorControlPrimary6XAttributeInteractionInfo); - Map readColorControlPrimary6YCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary6YAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary6YAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6YCommandParams); - result.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary6IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary6IntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterPrimary6IntensityAttributeCallback(), - readColorControlPrimary6IntensityCommandParams); - result.put( - "readPrimary6IntensityAttribute", - readColorControlPrimary6IntensityAttributeInteractionInfo); - Map readColorControlWhitePointXCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlWhitePointXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readWhitePointXAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlWhitePointXCommandParams); - result.put("readWhitePointXAttribute", readColorControlWhitePointXAttributeInteractionInfo); - Map readColorControlWhitePointYCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlWhitePointYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readWhitePointYAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlWhitePointYCommandParams); - result.put("readWhitePointYAttribute", readColorControlWhitePointYAttributeInteractionInfo); - Map readColorControlColorPointRXCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointRXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointRXAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRXCommandParams); - result.put("readColorPointRXAttribute", readColorControlColorPointRXAttributeInteractionInfo); - Map readColorControlColorPointRYCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointRYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointRYAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRYCommandParams); - result.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointRIntensityAttribute( - (ChipClusters.ColorControlCluster.ColorPointRIntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterColorPointRIntensityAttributeCallback(), - readColorControlColorPointRIntensityCommandParams); - result.put( - "readColorPointRIntensityAttribute", - readColorControlColorPointRIntensityAttributeInteractionInfo); - Map readColorControlColorPointGXCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointGXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointGXAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGXCommandParams); - result.put("readColorPointGXAttribute", readColorControlColorPointGXAttributeInteractionInfo); - Map readColorControlColorPointGYCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointGYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointGYAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGYCommandParams); - result.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointGIntensityAttribute( - (ChipClusters.ColorControlCluster.ColorPointGIntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterColorPointGIntensityAttributeCallback(), - readColorControlColorPointGIntensityCommandParams); - result.put( - "readColorPointGIntensityAttribute", - readColorControlColorPointGIntensityAttributeInteractionInfo); - Map readColorControlColorPointBXCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointBXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointBXAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBXCommandParams); - result.put("readColorPointBXAttribute", readColorControlColorPointBXAttributeInteractionInfo); - Map readColorControlColorPointBYCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointBYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointBYAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBYCommandParams); - result.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointBIntensityAttribute( - (ChipClusters.ColorControlCluster.ColorPointBIntensityAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterColorPointBIntensityAttributeCallback(), - readColorControlColorPointBIntensityCommandParams); - result.put( - "readColorPointBIntensityAttribute", - readColorControlColorPointBIntensityAttributeInteractionInfo); - Map readColorControlEnhancedCurrentHueCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlEnhancedCurrentHueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readEnhancedCurrentHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlEnhancedCurrentHueCommandParams); - result.put( - "readEnhancedCurrentHueAttribute", - readColorControlEnhancedCurrentHueAttributeInteractionInfo); - Map readColorControlEnhancedColorModeCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlEnhancedColorModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readEnhancedColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlEnhancedColorModeCommandParams); - result.put( - "readEnhancedColorModeAttribute", - readColorControlEnhancedColorModeAttributeInteractionInfo); - Map readColorControlColorLoopActiveCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorLoopActiveAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorLoopActiveAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopActiveCommandParams); - result.put( - "readColorLoopActiveAttribute", readColorControlColorLoopActiveAttributeInteractionInfo); - Map readColorControlColorLoopDirectionCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorLoopDirectionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorLoopDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopDirectionCommandParams); - result.put( - "readColorLoopDirectionAttribute", - readColorControlColorLoopDirectionAttributeInteractionInfo); - Map readColorControlColorLoopTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorLoopTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorLoopTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopTimeCommandParams); - result.put("readColorLoopTimeAttribute", readColorControlColorLoopTimeAttributeInteractionInfo); - Map readColorControlColorLoopStartEnhancedHueCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorLoopStartEnhancedHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopStartEnhancedHueCommandParams); - result.put( - "readColorLoopStartEnhancedHueAttribute", - readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo); - Map readColorControlColorLoopStoredEnhancedHueCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorLoopStoredEnhancedHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopStoredEnhancedHueCommandParams); - result.put( - "readColorLoopStoredEnhancedHueAttribute", - readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo); - Map readColorControlColorCapabilitiesCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorCapabilitiesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorCapabilitiesAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorCapabilitiesCommandParams); - result.put( - "readColorCapabilitiesAttribute", - readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTempPhysicalMinMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinMiredsCommandParams); - result.put( - "readColorTempPhysicalMinMiredsAttribute", - readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTempPhysicalMaxMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxMiredsCommandParams); - result.put( - "readColorTempPhysicalMaxMiredsAttribute", - readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCoupleColorTempToLevelMinMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams); - result.put( - "readCoupleColorTempToLevelMinMiredsAttribute", - readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readStartUpColorTemperatureMiredsAttribute( - (ChipClusters.ColorControlCluster - .StartUpColorTemperatureMiredsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterStartUpColorTemperatureMiredsAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams); - result.put( - "readStartUpColorTemperatureMiredsAttribute", - readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ColorControlCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterGeneratedCommandListAttributeCallback(), - readColorControlGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readColorControlGeneratedCommandListAttributeInteractionInfo); - Map readColorControlAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ColorControlCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedColorControlClusterAcceptedCommandListAttributeCallback(), - readColorControlAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readColorControlAcceptedCommandListAttributeInteractionInfo); - Map readColorControlEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readEventListAttribute( - (ChipClusters.ColorControlCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterEventListAttributeCallback(), - readColorControlEventListCommandParams); - result.put("readEventListAttribute", readColorControlEventListAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams); - result.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readColorControlFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readColorControlFeatureMapAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readBallastConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readBallastConfigurationPhysicalMinLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readPhysicalMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationPhysicalMinLevelCommandParams); - result.put( - "readPhysicalMinLevelAttribute", - readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo); - Map readBallastConfigurationPhysicalMaxLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readPhysicalMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationPhysicalMaxLevelCommandParams); - result.put( - "readPhysicalMaxLevelAttribute", - readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo); - Map readBallastConfigurationBallastStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationBallastStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readBallastStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationBallastStatusCommandParams); - result.put( - "readBallastStatusAttribute", - readBallastConfigurationBallastStatusAttributeInteractionInfo); - Map readBallastConfigurationMinLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationMinLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationMinLevelCommandParams); - result.put("readMinLevelAttribute", readBallastConfigurationMinLevelAttributeInteractionInfo); - Map readBallastConfigurationMaxLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationMaxLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationMaxLevelCommandParams); - result.put("readMaxLevelAttribute", readBallastConfigurationMaxLevelAttributeInteractionInfo); - Map readBallastConfigurationIntrinsicBallastFactorCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readIntrinsicBallastFactorAttribute( - (ChipClusters.BallastConfigurationCluster - .IntrinsicBallastFactorAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterIntrinsicBallastFactorAttributeCallback(), - readBallastConfigurationIntrinsicBallastFactorCommandParams); - result.put( - "readIntrinsicBallastFactorAttribute", - readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); - Map readBallastConfigurationBallastFactorAdjustmentCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readBallastFactorAdjustmentAttribute( - (ChipClusters.BallastConfigurationCluster - .BallastFactorAdjustmentAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterBallastFactorAdjustmentAttributeCallback(), - readBallastConfigurationBallastFactorAdjustmentCommandParams); - result.put( - "readBallastFactorAdjustmentAttribute", - readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); - Map readBallastConfigurationLampQuantityCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampQuantityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampQuantityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationLampQuantityCommandParams); - result.put( - "readLampQuantityAttribute", readBallastConfigurationLampQuantityAttributeInteractionInfo); - Map readBallastConfigurationLampTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampTypeAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBallastConfigurationLampTypeCommandParams); - result.put("readLampTypeAttribute", readBallastConfigurationLampTypeAttributeInteractionInfo); - Map readBallastConfigurationLampManufacturerCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampManufacturerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampManufacturerAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBallastConfigurationLampManufacturerCommandParams); - result.put( - "readLampManufacturerAttribute", - readBallastConfigurationLampManufacturerAttributeInteractionInfo); - Map readBallastConfigurationLampRatedHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampRatedHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampRatedHoursAttribute( - (ChipClusters.BallastConfigurationCluster.LampRatedHoursAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterLampRatedHoursAttributeCallback(), - readBallastConfigurationLampRatedHoursCommandParams); - result.put( - "readLampRatedHoursAttribute", - readBallastConfigurationLampRatedHoursAttributeInteractionInfo); - Map readBallastConfigurationLampBurnHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampBurnHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampBurnHoursAttribute( - (ChipClusters.BallastConfigurationCluster.LampBurnHoursAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterLampBurnHoursAttributeCallback(), - readBallastConfigurationLampBurnHoursCommandParams); - result.put( - "readLampBurnHoursAttribute", - readBallastConfigurationLampBurnHoursAttributeInteractionInfo); - Map readBallastConfigurationLampAlarmModeCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampAlarmModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampAlarmModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationLampAlarmModeCommandParams); - result.put( - "readLampAlarmModeAttribute", - readBallastConfigurationLampAlarmModeAttributeInteractionInfo); - Map readBallastConfigurationLampBurnHoursTripPointCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readLampBurnHoursTripPointAttribute( - (ChipClusters.BallastConfigurationCluster - .LampBurnHoursTripPointAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterLampBurnHoursTripPointAttributeCallback(), - readBallastConfigurationLampBurnHoursTripPointCommandParams); - result.put( - "readLampBurnHoursTripPointAttribute", - readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); - Map readBallastConfigurationGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.BallastConfigurationCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterGeneratedCommandListAttributeCallback(), - readBallastConfigurationGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readBallastConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readBallastConfigurationAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.BallastConfigurationCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterAcceptedCommandListAttributeCallback(), - readBallastConfigurationAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readBallastConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readBallastConfigurationEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readEventListAttribute( - (ChipClusters.BallastConfigurationCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterEventListAttributeCallback(), - readBallastConfigurationEventListCommandParams); - result.put("readEventListAttribute", readBallastConfigurationEventListAttributeInteractionInfo); - Map readBallastConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BallastConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBallastConfigurationClusterAttributeListAttributeCallback(), - readBallastConfigurationAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readBallastConfigurationAttributeListAttributeInteractionInfo); - Map readBallastConfigurationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBallastConfigurationFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readBallastConfigurationFeatureMapAttributeInteractionInfo); - Map readBallastConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBallastConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readBallastConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readIlluminanceMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readIlluminanceMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterMeasuredValueAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams); - result.put( - "readMeasuredValueAttribute", - readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterMinMeasuredValueAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams); - result.put( - "readMinMeasuredValueAttribute", - readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterMaxMeasuredValueAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams); - result.put( - "readMaxMeasuredValueAttribute", - readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementToleranceCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementToleranceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementToleranceCommandParams); - result.put( - "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readLightSensorTypeAttribute( - (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterLightSensorTypeAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams); - result.put( - "readLightSensorTypeAttribute", - readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.IlluminanceMeasurementCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterGeneratedCommandListAttributeCallback(), - readIlluminanceMeasurementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readIlluminanceMeasurementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.IlluminanceMeasurementCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterAcceptedCommandListAttributeCallback(), - readIlluminanceMeasurementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readIlluminanceMeasurementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readEventListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterEventListAttributeCallback(), - readIlluminanceMeasurementEventListCommandParams); - result.put( - "readEventListAttribute", readIlluminanceMeasurementEventListAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIlluminanceMeasurementFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readIlluminanceMeasurementFeatureMapAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readTemperatureMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readTemperatureMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.TemperatureMeasurementCluster.MeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterMeasuredValueAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams); - result.put( - "readMeasuredValueAttribute", - readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.TemperatureMeasurementCluster.MinMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterMinMeasuredValueAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams); - result.put( - "readMinMeasuredValueAttribute", - readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.TemperatureMeasurementCluster.MaxMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterMaxMeasuredValueAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams); - result.put( - "readMaxMeasuredValueAttribute", - readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementToleranceCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementToleranceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementToleranceCommandParams); - result.put( - "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.TemperatureMeasurementCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterGeneratedCommandListAttributeCallback(), - readTemperatureMeasurementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readTemperatureMeasurementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.TemperatureMeasurementCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterAcceptedCommandListAttributeCallback(), - readTemperatureMeasurementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readTemperatureMeasurementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readEventListAttribute( - (ChipClusters.TemperatureMeasurementCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterEventListAttributeCallback(), - readTemperatureMeasurementEventListCommandParams); - result.put( - "readEventListAttribute", readTemperatureMeasurementEventListAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTemperatureMeasurementFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readTemperatureMeasurementFeatureMapAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readPressureMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readPressureMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.PressureMeasurementCluster.MeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterMeasuredValueAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams); - result.put( - "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.PressureMeasurementCluster.MinMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterMinMeasuredValueAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams); - result.put( - "readMinMeasuredValueAttribute", - readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.PressureMeasurementCluster.MaxMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterMaxMeasuredValueAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams); - result.put( - "readMaxMeasuredValueAttribute", - readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementToleranceCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementToleranceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementToleranceCommandParams); - result.put("readToleranceAttribute", readPressureMeasurementToleranceAttributeInteractionInfo); - Map readPressureMeasurementScaledValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementScaledValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readScaledValueAttribute( - (ChipClusters.PressureMeasurementCluster.ScaledValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterScaledValueAttributeCallback(), - readPressureMeasurementScaledValueCommandParams); - result.put( - "readScaledValueAttribute", readPressureMeasurementScaledValueAttributeInteractionInfo); - Map readPressureMeasurementMinScaledValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinScaledValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMinScaledValueAttribute( - (ChipClusters.PressureMeasurementCluster.MinScaledValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterMinScaledValueAttributeCallback(), - readPressureMeasurementMinScaledValueCommandParams); - result.put( - "readMinScaledValueAttribute", - readPressureMeasurementMinScaledValueAttributeInteractionInfo); - Map readPressureMeasurementMaxScaledValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxScaledValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMaxScaledValueAttribute( - (ChipClusters.PressureMeasurementCluster.MaxScaledValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterMaxScaledValueAttributeCallback(), - readPressureMeasurementMaxScaledValueCommandParams); - result.put( - "readMaxScaledValueAttribute", - readPressureMeasurementMaxScaledValueAttributeInteractionInfo); - Map readPressureMeasurementScaledToleranceCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementScaledToleranceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readScaledToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementScaledToleranceCommandParams); - result.put( - "readScaledToleranceAttribute", - readPressureMeasurementScaledToleranceAttributeInteractionInfo); - Map readPressureMeasurementScaleCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementScaleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readScaleAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementScaleCommandParams); - result.put("readScaleAttribute", readPressureMeasurementScaleAttributeInteractionInfo); - Map readPressureMeasurementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.PressureMeasurementCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterGeneratedCommandListAttributeCallback(), - readPressureMeasurementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readPressureMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readPressureMeasurementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.PressureMeasurementCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterAcceptedCommandListAttributeCallback(), - readPressureMeasurementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readPressureMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readPressureMeasurementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readEventListAttribute( - (ChipClusters.PressureMeasurementCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterEventListAttributeCallback(), - readPressureMeasurementEventListCommandParams); - result.put("readEventListAttribute", readPressureMeasurementEventListAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPressureMeasurementFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readPressureMeasurementFeatureMapAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readPressureMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readFlowMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readFlowMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.FlowMeasurementCluster.MeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterMeasuredValueAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams); - result.put( - "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.FlowMeasurementCluster.MinMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterMinMeasuredValueAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams); - result.put( - "readMinMeasuredValueAttribute", - readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.FlowMeasurementCluster.MaxMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterMaxMeasuredValueAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams); - result.put( - "readMaxMeasuredValueAttribute", - readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementToleranceCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementToleranceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementToleranceCommandParams); - result.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.FlowMeasurementCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterGeneratedCommandListAttributeCallback(), - readFlowMeasurementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readFlowMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readFlowMeasurementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.FlowMeasurementCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterAcceptedCommandListAttributeCallback(), - readFlowMeasurementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readFlowMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readFlowMeasurementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readEventListAttribute( - (ChipClusters.FlowMeasurementCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedFlowMeasurementClusterEventListAttributeCallback(), - readFlowMeasurementEventListCommandParams); - result.put("readEventListAttribute", readFlowMeasurementEventListAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFlowMeasurementFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readFlowMeasurementFeatureMapAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readRelativeHumidityMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readRelativeHumidityMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .MeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterMeasuredValueAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams); - result.put( - "readMeasuredValueAttribute", - readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .MinMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterMinMeasuredValueAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams); - result.put( - "readMinMeasuredValueAttribute", - readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .MaxMeasuredValueAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterMaxMeasuredValueAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); - result.put( - "readMaxMeasuredValueAttribute", - readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementToleranceCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementToleranceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementToleranceCommandParams); - result.put( - "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map - readRelativeHumidityMeasurementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterGeneratedCommandListAttributeCallback(), - readRelativeHumidityMeasurementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo); - Map - readRelativeHumidityMeasurementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterAcceptedCommandListAttributeCallback(), - readRelativeHumidityMeasurementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readEventListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterEventListAttributeCallback(), - readRelativeHumidityMeasurementEventListCommandParams); - result.put( - "readEventListAttribute", readRelativeHumidityMeasurementEventListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRelativeHumidityMeasurementFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", - readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readOccupancySensingInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readOccupancySensingOccupancyCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams); - result.put("readOccupancyAttribute", readOccupancySensingOccupancyAttributeInteractionInfo); - Map readOccupancySensingOccupancySensorTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancySensorTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readOccupancySensorTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancySensorTypeCommandParams); - result.put( - "readOccupancySensorTypeAttribute", - readOccupancySensingOccupancySensorTypeAttributeInteractionInfo); - Map readOccupancySensingOccupancySensorTypeBitmapCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readOccupancySensorTypeBitmapAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancySensorTypeBitmapCommandParams); - result.put( - "readOccupancySensorTypeBitmapAttribute", - readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map - readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readPIROccupiedToUnoccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams); - result.put( - "readPIROccupiedToUnoccupiedDelayAttribute", - readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map - readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readPIRUnoccupiedToOccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams); - result.put( - "readPIRUnoccupiedToOccupiedDelayAttribute", - readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map - readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readPIRUnoccupiedToOccupiedThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams); - result.put( - "readPIRUnoccupiedToOccupiedThresholdAttribute", - readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map - readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = - new LinkedHashMap(); - InteractionInfo - readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readUltrasonicOccupiedToUnoccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams); - result.put( - "readUltrasonicOccupiedToUnoccupiedDelayAttribute", - readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map - readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = - new LinkedHashMap(); - InteractionInfo - readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readUltrasonicUnoccupiedToOccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams); - result.put( - "readUltrasonicUnoccupiedToOccupiedDelayAttribute", - readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map - readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = - new LinkedHashMap(); - InteractionInfo - readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readUltrasonicUnoccupiedToOccupiedThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams); - result.put( - "readUltrasonicUnoccupiedToOccupiedThresholdAttribute", - readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map - readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = - new LinkedHashMap(); - InteractionInfo - readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readPhysicalContactOccupiedToUnoccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams); - result.put( - "readPhysicalContactOccupiedToUnoccupiedDelayAttribute", - readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map - readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = - new LinkedHashMap(); - InteractionInfo - readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readPhysicalContactUnoccupiedToOccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams); - result.put( - "readPhysicalContactUnoccupiedToOccupiedDelayAttribute", - readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map - readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = - new LinkedHashMap(); - InteractionInfo - readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readPhysicalContactUnoccupiedToOccupiedThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams); - result.put( - "readPhysicalContactUnoccupiedToOccupiedThresholdAttribute", - readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map readOccupancySensingGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.OccupancySensingCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOccupancySensingClusterGeneratedCommandListAttributeCallback(), - readOccupancySensingGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readOccupancySensingGeneratedCommandListAttributeInteractionInfo); - Map readOccupancySensingAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.OccupancySensingCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOccupancySensingClusterAcceptedCommandListAttributeCallback(), - readOccupancySensingAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readOccupancySensingAcceptedCommandListAttributeInteractionInfo); - Map readOccupancySensingEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readEventListAttribute( - (ChipClusters.OccupancySensingCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedOccupancySensingClusterEventListAttributeCallback(), - readOccupancySensingEventListCommandParams); - result.put("readEventListAttribute", readOccupancySensingEventListAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOccupancySensingFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readOccupancySensingFeatureMapAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readOccupancySensingClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readWakeOnLanInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readWakeOnLanMACAddressCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanMACAddressAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readMACAddressAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanMACAddressCommandParams); - result.put("readMACAddressAttribute", readWakeOnLanMACAddressAttributeInteractionInfo); - Map readWakeOnLanGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.WakeOnLanCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWakeOnLanClusterGeneratedCommandListAttributeCallback(), - readWakeOnLanGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readWakeOnLanGeneratedCommandListAttributeInteractionInfo); - Map readWakeOnLanAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.WakeOnLanCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWakeOnLanClusterAcceptedCommandListAttributeCallback(), - readWakeOnLanAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readWakeOnLanAcceptedCommandListAttributeInteractionInfo); - Map readWakeOnLanEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readEventListAttribute( - (ChipClusters.WakeOnLanCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterEventListAttributeCallback(), - readWakeOnLanEventListCommandParams); - result.put("readEventListAttribute", readWakeOnLanEventListAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams); - result.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWakeOnLanFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readWakeOnLanFeatureMapAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readChannelInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readChannelChannelListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readChannelListAttribute( - (ChipClusters.ChannelCluster.ChannelListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterChannelListAttributeCallback(), - readChannelChannelListCommandParams); - result.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ChannelCluster.GeneratedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedChannelClusterGeneratedCommandListAttributeCallback(), - readChannelGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readChannelGeneratedCommandListAttributeInteractionInfo); - Map readChannelAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ChannelCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedChannelClusterAcceptedCommandListAttributeCallback(), - readChannelAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", readChannelAcceptedCommandListAttributeInteractionInfo); - Map readChannelEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readEventListAttribute( - (ChipClusters.ChannelCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterEventListAttributeCallback(), - readChannelEventListCommandParams); - result.put("readEventListAttribute", readChannelEventListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams); - result.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readChannelFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readChannelFeatureMapAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readTargetNavigatorInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readTargetNavigatorTargetListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readTargetListAttribute( - (ChipClusters.TargetNavigatorCluster.TargetListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetListAttributeCallback(), - readTargetNavigatorTargetListCommandParams); - result.put("readTargetListAttribute", readTargetNavigatorTargetListAttributeInteractionInfo); - Map readTargetNavigatorCurrentTargetCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentTargetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readCurrentTargetAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentTargetCommandParams); - result.put( - "readCurrentTargetAttribute", readTargetNavigatorCurrentTargetAttributeInteractionInfo); - Map readTargetNavigatorGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.TargetNavigatorCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterGeneratedCommandListAttributeCallback(), - readTargetNavigatorGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readTargetNavigatorGeneratedCommandListAttributeInteractionInfo); - Map readTargetNavigatorAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.TargetNavigatorCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterAcceptedCommandListAttributeCallback(), - readTargetNavigatorAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readTargetNavigatorAcceptedCommandListAttributeInteractionInfo); - Map readTargetNavigatorEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readEventListAttribute( - (ChipClusters.TargetNavigatorCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedTargetNavigatorClusterEventListAttributeCallback(), - readTargetNavigatorEventListCommandParams); - result.put("readEventListAttribute", readTargetNavigatorEventListAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTargetNavigatorFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readTargetNavigatorFeatureMapAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readMediaPlaybackInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readMediaPlaybackCurrentStateCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackCurrentStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readCurrentStateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackCurrentStateCommandParams); - result.put("readCurrentStateAttribute", readMediaPlaybackCurrentStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readStartTimeAttribute( - (ChipClusters.MediaPlaybackCluster.StartTimeAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterStartTimeAttributeCallback(), - readMediaPlaybackStartTimeCommandParams); - result.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readDurationAttribute( - (ChipClusters.MediaPlaybackCluster.DurationAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterDurationAttributeCallback(), - readMediaPlaybackDurationCommandParams); - result.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readPlaybackSpeedAttribute((ChipClusters.FloatAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readMediaPlaybackPlaybackSpeedCommandParams); - result.put( - "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readSeekRangeEndAttribute( - (ChipClusters.MediaPlaybackCluster.SeekRangeEndAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedMediaPlaybackClusterSeekRangeEndAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams); - result.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readSeekRangeStartAttribute( - (ChipClusters.MediaPlaybackCluster.SeekRangeStartAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaPlaybackClusterSeekRangeStartAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams); - result.put( - "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.MediaPlaybackCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaPlaybackClusterGeneratedCommandListAttributeCallback(), - readMediaPlaybackGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readMediaPlaybackGeneratedCommandListAttributeInteractionInfo); - Map readMediaPlaybackAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.MediaPlaybackCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaPlaybackClusterAcceptedCommandListAttributeCallback(), - readMediaPlaybackAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readMediaPlaybackAcceptedCommandListAttributeInteractionInfo); - Map readMediaPlaybackEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readEventListAttribute( - (ChipClusters.MediaPlaybackCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterEventListAttributeCallback(), - readMediaPlaybackEventListCommandParams); - result.put("readEventListAttribute", readMediaPlaybackEventListAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readMediaPlaybackFeatureMapAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readMediaInputInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readMediaInputInputListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputInputListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readInputListAttribute( - (ChipClusters.MediaInputCluster.InputListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterInputListAttributeCallback(), - readMediaInputInputListCommandParams); - result.put("readInputListAttribute", readMediaInputInputListAttributeInteractionInfo); - Map readMediaInputCurrentInputCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputCurrentInputAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readCurrentInputAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentInputCommandParams); - result.put("readCurrentInputAttribute", readMediaInputCurrentInputAttributeInteractionInfo); - Map readMediaInputGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.MediaInputCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaInputClusterGeneratedCommandListAttributeCallback(), - readMediaInputGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readMediaInputGeneratedCommandListAttributeInteractionInfo); - Map readMediaInputAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.MediaInputCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaInputClusterAcceptedCommandListAttributeCallback(), - readMediaInputAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readMediaInputAcceptedCommandListAttributeInteractionInfo); - Map readMediaInputEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readEventListAttribute( - (ChipClusters.MediaInputCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterEventListAttributeCallback(), - readMediaInputEventListCommandParams); - result.put("readEventListAttribute", readMediaInputEventListAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams); - result.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaInputFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readMediaInputFeatureMapAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readLowPowerInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readLowPowerGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.LowPowerCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLowPowerClusterGeneratedCommandListAttributeCallback(), - readLowPowerGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readLowPowerGeneratedCommandListAttributeInteractionInfo); - Map readLowPowerAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.LowPowerCluster.AcceptedCommandListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedLowPowerClusterAcceptedCommandListAttributeCallback(), - readLowPowerAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readLowPowerAcceptedCommandListAttributeInteractionInfo); - Map readLowPowerEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readEventListAttribute( - (ChipClusters.LowPowerCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLowPowerClusterEventListAttributeCallback(), - readLowPowerEventListCommandParams); - result.put("readEventListAttribute", readLowPowerEventListAttributeInteractionInfo); - Map readLowPowerAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams); - result.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readLowPowerFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readLowPowerFeatureMapAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams); - result.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readKeypadInputInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readKeypadInputGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.KeypadInputCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedKeypadInputClusterGeneratedCommandListAttributeCallback(), - readKeypadInputGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readKeypadInputGeneratedCommandListAttributeInteractionInfo); - Map readKeypadInputAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.KeypadInputCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedKeypadInputClusterAcceptedCommandListAttributeCallback(), - readKeypadInputAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readKeypadInputAcceptedCommandListAttributeInteractionInfo); - Map readKeypadInputEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readEventListAttribute( - (ChipClusters.KeypadInputCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterEventListAttributeCallback(), - readKeypadInputEventListCommandParams); - result.put("readEventListAttribute", readKeypadInputEventListAttributeInteractionInfo); - Map readKeypadInputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams); - result.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readKeypadInputFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readKeypadInputFeatureMapAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readContentLauncherInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readContentLauncherAcceptHeaderCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAcceptHeaderAttribute( - (ChipClusters.ContentLauncherCluster.AcceptHeaderAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAcceptHeaderAttributeCallback(), - readContentLauncherAcceptHeaderCommandParams); - result.put( - "readAcceptHeaderAttribute", readContentLauncherAcceptHeaderAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readSupportedStreamingProtocolsAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams); - result.put( - "readSupportedStreamingProtocolsAttribute", - readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ContentLauncherCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterGeneratedCommandListAttributeCallback(), - readContentLauncherGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readContentLauncherGeneratedCommandListAttributeInteractionInfo); - Map readContentLauncherAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ContentLauncherCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAcceptedCommandListAttributeCallback(), - readContentLauncherAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readContentLauncherAcceptedCommandListAttributeInteractionInfo); - Map readContentLauncherEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readEventListAttribute( - (ChipClusters.ContentLauncherCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedContentLauncherClusterEventListAttributeCallback(), - readContentLauncherEventListCommandParams); - result.put("readEventListAttribute", readContentLauncherEventListAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readContentLauncherFeatureMapAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readAudioOutputInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readAudioOutputOutputListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputOutputListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readOutputListAttribute( - (ChipClusters.AudioOutputCluster.OutputListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterOutputListAttributeCallback(), - readAudioOutputOutputListCommandParams); - result.put("readOutputListAttribute", readAudioOutputOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentOutputCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentOutputAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readCurrentOutputAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentOutputCommandParams); - result.put("readCurrentOutputAttribute", readAudioOutputCurrentOutputAttributeInteractionInfo); - Map readAudioOutputGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.AudioOutputCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAudioOutputClusterGeneratedCommandListAttributeCallback(), - readAudioOutputGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readAudioOutputGeneratedCommandListAttributeInteractionInfo); - Map readAudioOutputAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.AudioOutputCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAudioOutputClusterAcceptedCommandListAttributeCallback(), - readAudioOutputAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readAudioOutputAcceptedCommandListAttributeInteractionInfo); - Map readAudioOutputEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readEventListAttribute( - (ChipClusters.AudioOutputCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterEventListAttributeCallback(), - readAudioOutputEventListCommandParams); - result.put("readEventListAttribute", readAudioOutputEventListAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams); - result.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAudioOutputFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readAudioOutputFeatureMapAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readApplicationLauncherInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readApplicationLauncherCatalogListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherCatalogListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readCatalogListAttribute( - (ChipClusters.ApplicationLauncherCluster.CatalogListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterCatalogListAttributeCallback(), - readApplicationLauncherCatalogListCommandParams); - result.put( - "readCatalogListAttribute", readApplicationLauncherCatalogListAttributeInteractionInfo); - Map readApplicationLauncherGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ApplicationLauncherCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterGeneratedCommandListAttributeCallback(), - readApplicationLauncherGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readApplicationLauncherGeneratedCommandListAttributeInteractionInfo); - Map readApplicationLauncherAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ApplicationLauncherCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterAcceptedCommandListAttributeCallback(), - readApplicationLauncherAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readApplicationLauncherAcceptedCommandListAttributeInteractionInfo); - Map readApplicationLauncherEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readEventListAttribute( - (ChipClusters.ApplicationLauncherCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterEventListAttributeCallback(), - readApplicationLauncherEventListCommandParams); - result.put("readEventListAttribute", readApplicationLauncherEventListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readApplicationLauncherFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readApplicationLauncherFeatureMapAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readApplicationLauncherClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readApplicationBasicInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readApplicationBasicVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams); - result.put("readVendorNameAttribute", readApplicationBasicVendorNameAttributeInteractionInfo); - Map readApplicationBasicVendorIDCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicVendorIDCommandParams); - result.put("readVendorIDAttribute", readApplicationBasicVendorIDAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationNameCommandParams); - result.put( - "readApplicationNameAttribute", - readApplicationBasicApplicationNameAttributeInteractionInfo); - Map readApplicationBasicProductIDCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicProductIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicProductIDCommandParams); - result.put("readProductIDAttribute", readApplicationBasicProductIDAttributeInteractionInfo); - Map readApplicationBasicStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicStatusCommandParams); - result.put("readStatusAttribute", readApplicationBasicStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationVersionAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams); - result.put( - "readApplicationVersionAttribute", - readApplicationBasicApplicationVersionAttributeInteractionInfo); - Map readApplicationBasicAllowedVendorListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicAllowedVendorListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readAllowedVendorListAttribute( - (ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback(), - readApplicationBasicAllowedVendorListCommandParams); - result.put( - "readAllowedVendorListAttribute", - readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ApplicationBasicCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationBasicClusterGeneratedCommandListAttributeCallback(), - readApplicationBasicGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readApplicationBasicGeneratedCommandListAttributeInteractionInfo); - Map readApplicationBasicAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ApplicationBasicCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationBasicClusterAcceptedCommandListAttributeCallback(), - readApplicationBasicAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readApplicationBasicAcceptedCommandListAttributeInteractionInfo); - Map readApplicationBasicEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readEventListAttribute( - (ChipClusters.ApplicationBasicCluster.EventListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedApplicationBasicClusterEventListAttributeCallback(), - readApplicationBasicEventListCommandParams); - result.put("readEventListAttribute", readApplicationBasicEventListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readApplicationBasicFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readApplicationBasicFeatureMapAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readApplicationBasicClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readAccountLoginInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readAccountLoginGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.AccountLoginCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccountLoginClusterGeneratedCommandListAttributeCallback(), - readAccountLoginGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readAccountLoginGeneratedCommandListAttributeInteractionInfo); - Map readAccountLoginAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.AccountLoginCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccountLoginClusterAcceptedCommandListAttributeCallback(), - readAccountLoginAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readAccountLoginAcceptedCommandListAttributeInteractionInfo); - Map readAccountLoginEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readEventListAttribute( - (ChipClusters.AccountLoginCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterEventListAttributeCallback(), - readAccountLoginEventListCommandParams); - result.put("readEventListAttribute", readAccountLoginEventListAttributeInteractionInfo); - Map readAccountLoginAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams); - result.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAccountLoginFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readAccountLoginFeatureMapAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readElectricalMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readElectricalMeasurementMeasurementTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams); - result.put( - "readMeasurementTypeAttribute", - readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageCommandParams); - result.put( - "readDcVoltageAttribute", readElectricalMeasurementDcVoltageAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcVoltageMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageMinCommandParams); - result.put( - "readDcVoltageMinAttribute", readElectricalMeasurementDcVoltageMinAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcVoltageMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageMaxCommandParams); - result.put( - "readDcVoltageMaxAttribute", readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentCommandParams); - result.put( - "readDcCurrentAttribute", readElectricalMeasurementDcCurrentAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcCurrentMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentMinCommandParams); - result.put( - "readDcCurrentMinAttribute", readElectricalMeasurementDcCurrentMinAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcCurrentMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentMaxCommandParams); - result.put( - "readDcCurrentMaxAttribute", readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcPowerAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerCommandParams); - result.put("readDcPowerAttribute", readElectricalMeasurementDcPowerAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcPowerMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerMinCommandParams); - result.put( - "readDcPowerMinAttribute", readElectricalMeasurementDcPowerMinAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcPowerMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerMaxCommandParams); - result.put( - "readDcPowerMaxAttribute", readElectricalMeasurementDcPowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcVoltageMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageMultiplierCommandParams); - result.put( - "readDcVoltageMultiplierAttribute", - readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcVoltageDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageDivisorCommandParams); - result.put( - "readDcVoltageDivisorAttribute", - readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentMultiplierCommandParams); - result.put( - "readDcCurrentMultiplierAttribute", - readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcCurrentDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentDivisorCommandParams); - result.put( - "readDcCurrentDivisorAttribute", - readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcPowerMultiplierAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerMultiplierCommandParams); - result.put( - "readDcPowerMultiplierAttribute", - readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readDcPowerDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerDivisorCommandParams); - result.put( - "readDcPowerDivisorAttribute", - readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyCommandParams); - result.put( - "readAcFrequencyAttribute", readElectricalMeasurementAcFrequencyAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcFrequencyMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyMinCommandParams); - result.put( - "readAcFrequencyMinAttribute", - readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcFrequencyMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyMaxCommandParams); - result.put( - "readAcFrequencyMaxAttribute", - readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo); - Map readElectricalMeasurementNeutralCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementNeutralCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readNeutralCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementNeutralCurrentCommandParams); - result.put( - "readNeutralCurrentAttribute", - readElectricalMeasurementNeutralCurrentAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams); - result.put( - "readTotalActivePowerAttribute", - readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementTotalReactivePowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readTotalReactivePowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalReactivePowerCommandParams); - result.put( - "readTotalReactivePowerAttribute", - readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo); - Map readElectricalMeasurementTotalApparentPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readTotalApparentPowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalApparentPowerCommandParams); - result.put( - "readTotalApparentPowerAttribute", - readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo); - Map - readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasured1stHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams); - result.put( - "readMeasured1stHarmonicCurrentAttribute", - readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasured3rdHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams); - result.put( - "readMeasured3rdHarmonicCurrentAttribute", - readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasured5thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams); - result.put( - "readMeasured5thHarmonicCurrentAttribute", - readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasured7thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams); - result.put( - "readMeasured7thHarmonicCurrentAttribute", - readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasured9thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams); - result.put( - "readMeasured9thHarmonicCurrentAttribute", - readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasured11thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams); - result.put( - "readMeasured11thHarmonicCurrentAttribute", - readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasuredPhase1stHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams); - result.put( - "readMeasuredPhase1stHarmonicCurrentAttribute", - readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasuredPhase3rdHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams); - result.put( - "readMeasuredPhase3rdHarmonicCurrentAttribute", - readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasuredPhase5thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams); - result.put( - "readMeasuredPhase5thHarmonicCurrentAttribute", - readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasuredPhase7thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams); - result.put( - "readMeasuredPhase7thHarmonicCurrentAttribute", - readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasuredPhase9thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams); - result.put( - "readMeasuredPhase9thHarmonicCurrentAttribute", - readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasuredPhase11thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams); - result.put( - "readMeasuredPhase11thHarmonicCurrentAttribute", - readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcFrequencyMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyMultiplierCommandParams); - result.put( - "readAcFrequencyMultiplierAttribute", - readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcFrequencyDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyDivisorCommandParams); - result.put( - "readAcFrequencyDivisorAttribute", - readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo); - Map readElectricalMeasurementPowerMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readPowerMultiplierAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementPowerMultiplierCommandParams); - result.put( - "readPowerMultiplierAttribute", - readElectricalMeasurementPowerMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementPowerDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readPowerDivisorAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementPowerDivisorCommandParams); - result.put( - "readPowerDivisorAttribute", readElectricalMeasurementPowerDivisorAttributeInteractionInfo); - Map - readElectricalMeasurementHarmonicCurrentMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readHarmonicCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementHarmonicCurrentMultiplierCommandParams); - result.put( - "readHarmonicCurrentMultiplierAttribute", - readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo); - Map - readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readPhaseHarmonicCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams); - result.put( - "readPhaseHarmonicCurrentMultiplierAttribute", - readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readInstantaneousVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousVoltageCommandParams); - result.put( - "readInstantaneousVoltageAttribute", - readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo); - Map - readElectricalMeasurementInstantaneousLineCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readInstantaneousLineCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousLineCurrentCommandParams); - result.put( - "readInstantaneousLineCurrentAttribute", - readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementInstantaneousActiveCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readInstantaneousActiveCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousActiveCurrentCommandParams); - result.put( - "readInstantaneousActiveCurrentAttribute", - readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo); - Map - readElectricalMeasurementInstantaneousReactiveCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readInstantaneousReactiveCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousReactiveCurrentCommandParams); - result.put( - "readInstantaneousReactiveCurrentAttribute", - readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readInstantaneousPowerAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousPowerCommandParams); - result.put( - "readInstantaneousPowerAttribute", - readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams); - result.put( - "readRmsVoltageAttribute", readElectricalMeasurementRmsVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMinCommandParams); - result.put( - "readRmsVoltageMinAttribute", - readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMaxCommandParams); - result.put( - "readRmsVoltageMaxAttribute", - readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentCommandParams); - result.put( - "readRmsCurrentAttribute", readElectricalMeasurementRmsCurrentAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMinCommandParams); - result.put( - "readRmsCurrentMinAttribute", - readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMaxCommandParams); - result.put( - "readRmsCurrentMaxAttribute", - readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerCommandParams); - result.put( - "readActivePowerAttribute", readElectricalMeasurementActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMinCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerMinAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMinCommandParams); - result.put( - "readActivePowerMinAttribute", - readElectricalMeasurementActivePowerMinAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMaxCommandParams); - result.put( - "readActivePowerMaxAttribute", - readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementReactivePowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactivePowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readReactivePowerAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactivePowerCommandParams); - result.put( - "readReactivePowerAttribute", - readElectricalMeasurementReactivePowerAttributeInteractionInfo); - Map readElectricalMeasurementApparentPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementApparentPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readApparentPowerAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementApparentPowerCommandParams); - result.put( - "readApparentPowerAttribute", - readElectricalMeasurementApparentPowerAttributeInteractionInfo); - Map readElectricalMeasurementPowerFactorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerFactorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readPowerFactorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPowerFactorCommandParams); - result.put( - "readPowerFactorAttribute", readElectricalMeasurementPowerFactorAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsVoltageMeasurementPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams); - result.put( - "readAverageRmsVoltageMeasurementPeriodAttribute", - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsUnderVoltageCounterAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams); - result.put( - "readAverageRmsUnderVoltageCounterAttribute", - readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); - Map - readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeOverVoltagePeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams); - result.put( - "readRmsExtremeOverVoltagePeriodAttribute", - readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); - Map - readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeUnderVoltagePeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams); - result.put( - "readRmsExtremeUnderVoltagePeriodAttribute", - readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSagPeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSagPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagPeriodCommandParams); - result.put( - "readRmsVoltageSagPeriodAttribute", - readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSwellPeriodCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSwellPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellPeriodCommandParams); - result.put( - "readRmsVoltageSwellPeriodAttribute", - readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); - Map readElectricalMeasurementAcVoltageMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcVoltageMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcVoltageMultiplierCommandParams); - result.put( - "readAcVoltageMultiplierAttribute", - readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcVoltageDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcVoltageDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcVoltageDivisorCommandParams); - result.put( - "readAcVoltageDivisorAttribute", - readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo); - Map readElectricalMeasurementAcCurrentMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcCurrentMultiplierCommandParams); - result.put( - "readAcCurrentMultiplierAttribute", - readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcCurrentDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcCurrentDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcCurrentDivisorCommandParams); - result.put( - "readAcCurrentDivisorAttribute", - readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo); - Map readElectricalMeasurementAcPowerMultiplierCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcPowerMultiplierAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcPowerMultiplierCommandParams); - result.put( - "readAcPowerMultiplierAttribute", - readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcPowerDivisorCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcPowerDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcPowerDivisorCommandParams); - result.put( - "readAcPowerDivisorAttribute", - readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo); - Map readElectricalMeasurementOverloadAlarmsMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readOverloadAlarmsMaskAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementOverloadAlarmsMaskCommandParams); - result.put( - "readOverloadAlarmsMaskAttribute", - readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); - Map readElectricalMeasurementVoltageOverloadCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementVoltageOverloadAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readVoltageOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementVoltageOverloadCommandParams); - result.put( - "readVoltageOverloadAttribute", - readElectricalMeasurementVoltageOverloadAttributeInteractionInfo); - Map readElectricalMeasurementCurrentOverloadCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementCurrentOverloadAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readCurrentOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementCurrentOverloadCommandParams); - result.put( - "readCurrentOverloadAttribute", - readElectricalMeasurementCurrentOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcOverloadAlarmsMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcOverloadAlarmsMaskAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcOverloadAlarmsMaskCommandParams); - result.put( - "readAcOverloadAlarmsMaskAttribute", - readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); - Map readElectricalMeasurementAcVoltageOverloadCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcVoltageOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcVoltageOverloadCommandParams); - result.put( - "readAcVoltageOverloadAttribute", - readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcCurrentOverloadCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcCurrentOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcCurrentOverloadCommandParams); - result.put( - "readAcCurrentOverloadAttribute", - readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcActivePowerOverloadCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcActivePowerOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcActivePowerOverloadCommandParams); - result.put( - "readAcActivePowerOverloadAttribute", - readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo); - Map - readElectricalMeasurementAcReactivePowerOverloadCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcReactivePowerOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcReactivePowerOverloadCommandParams); - result.put( - "readAcReactivePowerOverloadAttribute", - readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsOverVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsOverVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsOverVoltageCommandParams); - result.put( - "readAverageRmsOverVoltageAttribute", - readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsUnderVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsUnderVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCommandParams); - result.put( - "readAverageRmsUnderVoltageAttribute", - readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeOverVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeOverVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltageCommandParams); - result.put( - "readRmsExtremeOverVoltageAttribute", - readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeUnderVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeUnderVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltageCommandParams); - result.put( - "readRmsExtremeUnderVoltageAttribute", - readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSagCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSagAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagCommandParams); - result.put( - "readRmsVoltageSagAttribute", - readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSwellCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSwellAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellCommandParams); - result.put( - "readRmsVoltageSwellAttribute", - readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo); - Map readElectricalMeasurementLineCurrentPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readLineCurrentPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementLineCurrentPhaseBCommandParams); - result.put( - "readLineCurrentPhaseBAttribute", - readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActiveCurrentPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActiveCurrentPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActiveCurrentPhaseBCommandParams); - result.put( - "readActiveCurrentPhaseBAttribute", - readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementReactiveCurrentPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readReactiveCurrentPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactiveCurrentPhaseBCommandParams); - result.put( - "readReactiveCurrentPhaseBAttribute", - readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltagePhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltagePhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltagePhaseBCommandParams); - result.put( - "readRmsVoltagePhaseBAttribute", - readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMinPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageMinPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMinPhaseBCommandParams); - result.put( - "readRmsVoltageMinPhaseBAttribute", - readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageMaxPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams); - result.put( - "readRmsVoltageMaxPhaseBAttribute", - readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentPhaseBCommandParams); - result.put( - "readRmsCurrentPhaseBAttribute", - readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMinPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentMinPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMinPhaseBCommandParams); - result.put( - "readRmsCurrentMinPhaseBAttribute", - readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentMaxPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams); - result.put( - "readRmsCurrentMaxPhaseBAttribute", - readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerPhaseBCommandParams); - result.put( - "readActivePowerPhaseBAttribute", - readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMinPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerMinPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMinPhaseBCommandParams); - result.put( - "readActivePowerMinPhaseBAttribute", - readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMaxPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerMaxPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMaxPhaseBCommandParams); - result.put( - "readActivePowerMaxPhaseBAttribute", - readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementReactivePowerPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readReactivePowerPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactivePowerPhaseBCommandParams); - result.put( - "readReactivePowerPhaseBAttribute", - readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementApparentPowerPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readApparentPowerPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementApparentPowerPhaseBCommandParams); - result.put( - "readApparentPowerPhaseBAttribute", - readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementPowerFactorPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readPowerFactorPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPowerFactorPhaseBCommandParams); - result.put( - "readPowerFactorPhaseBAttribute", - readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsVoltageMeasurementPeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams); - result.put( - "readAverageRmsVoltageMeasurementPeriodPhaseBAttribute", - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsOverVoltageCounterPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams); - result.put( - "readAverageRmsOverVoltageCounterPhaseBAttribute", - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsUnderVoltageCounterPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams); - result.put( - "readAverageRmsUnderVoltageCounterPhaseBAttribute", - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeOverVoltagePeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams); - result.put( - "readRmsExtremeOverVoltagePeriodPhaseBAttribute", - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeUnderVoltagePeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams); - result.put( - "readRmsExtremeUnderVoltagePeriodPhaseBAttribute", - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSagPeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams); - result.put( - "readRmsVoltageSagPeriodPhaseBAttribute", - readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo); - Map - readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSwellPeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams); - result.put( - "readRmsVoltageSwellPeriodPhaseBAttribute", - readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementLineCurrentPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readLineCurrentPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementLineCurrentPhaseCCommandParams); - result.put( - "readLineCurrentPhaseCAttribute", - readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActiveCurrentPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActiveCurrentPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActiveCurrentPhaseCCommandParams); - result.put( - "readActiveCurrentPhaseCAttribute", - readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementReactiveCurrentPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readReactiveCurrentPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactiveCurrentPhaseCCommandParams); - result.put( - "readReactiveCurrentPhaseCAttribute", - readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltagePhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltagePhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltagePhaseCCommandParams); - result.put( - "readRmsVoltagePhaseCAttribute", - readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMinPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageMinPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMinPhaseCCommandParams); - result.put( - "readRmsVoltageMinPhaseCAttribute", - readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageMaxPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams); - result.put( - "readRmsVoltageMaxPhaseCAttribute", - readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentPhaseCCommandParams); - result.put( - "readRmsCurrentPhaseCAttribute", - readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMinPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentMinPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMinPhaseCCommandParams); - result.put( - "readRmsCurrentMinPhaseCAttribute", - readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsCurrentMaxPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams); - result.put( - "readRmsCurrentMaxPhaseCAttribute", - readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerPhaseCCommandParams); - result.put( - "readActivePowerPhaseCAttribute", - readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMinPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerMinPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMinPhaseCCommandParams); - result.put( - "readActivePowerMinPhaseCAttribute", - readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMaxPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readActivePowerMaxPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMaxPhaseCCommandParams); - result.put( - "readActivePowerMaxPhaseCAttribute", - readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementReactivePowerPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readReactivePowerPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactivePowerPhaseCCommandParams); - result.put( - "readReactivePowerPhaseCAttribute", - readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementApparentPowerPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readApparentPowerPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementApparentPowerPhaseCCommandParams); - result.put( - "readApparentPowerPhaseCAttribute", - readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementPowerFactorPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readPowerFactorPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPowerFactorPhaseCCommandParams); - result.put( - "readPowerFactorPhaseCAttribute", - readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsVoltageMeasurementPeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams); - result.put( - "readAverageRmsVoltageMeasurementPeriodPhaseCAttribute", - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsOverVoltageCounterPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams); - result.put( - "readAverageRmsOverVoltageCounterPhaseCAttribute", - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAverageRmsUnderVoltageCounterPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams); - result.put( - "readAverageRmsUnderVoltageCounterPhaseCAttribute", - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeOverVoltagePeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams); - result.put( - "readRmsExtremeOverVoltagePeriodPhaseCAttribute", - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsExtremeUnderVoltagePeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams); - result.put( - "readRmsExtremeUnderVoltagePeriodPhaseCAttribute", - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSagPeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams); - result.put( - "readRmsVoltageSagPeriodPhaseCAttribute", - readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo); - Map - readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageSwellPeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams); - result.put( - "readRmsVoltageSwellPeriodPhaseCAttribute", - readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.ElectricalMeasurementCluster - .GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectricalMeasurementClusterGeneratedCommandListAttributeCallback(), - readElectricalMeasurementGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readElectricalMeasurementAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.ElectricalMeasurementCluster - .AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectricalMeasurementClusterAcceptedCommandListAttributeCallback(), - readElectricalMeasurementAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readElectricalMeasurementEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readEventListAttribute( - (ChipClusters.ElectricalMeasurementCluster.EventListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectricalMeasurementClusterEventListAttributeCallback(), - readElectricalMeasurementEventListCommandParams); - result.put( - "readEventListAttribute", readElectricalMeasurementEventListAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams); - result.put( - "readAttributeListAttribute", - readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementFeatureMapCommandParams); - result.put( - "readFeatureMapAttribute", readElectricalMeasurementFeatureMapAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", - readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readUnitTestingInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readUnitTestingBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingBooleanCommandParams); - result.put("readBooleanAttribute", readUnitTestingBooleanAttributeInteractionInfo); - Map readUnitTestingBitmap8CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingBitmap8CommandParams); - result.put("readBitmap8Attribute", readUnitTestingBitmap8AttributeInteractionInfo); - Map readUnitTestingBitmap16CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingBitmap16CommandParams); - result.put("readBitmap16Attribute", readUnitTestingBitmap16AttributeInteractionInfo); - Map readUnitTestingBitmap32CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingBitmap32CommandParams); - result.put("readBitmap32Attribute", readUnitTestingBitmap32AttributeInteractionInfo); - Map readUnitTestingBitmap64CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingBitmap64CommandParams); - result.put("readBitmap64Attribute", readUnitTestingBitmap64AttributeInteractionInfo); - Map readUnitTestingInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt8uCommandParams); - result.put("readInt8uAttribute", readUnitTestingInt8uAttributeInteractionInfo); - Map readUnitTestingInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt16uCommandParams); - result.put("readInt16uAttribute", readUnitTestingInt16uAttributeInteractionInfo); - Map readUnitTestingInt24uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt24uCommandParams); - result.put("readInt24uAttribute", readUnitTestingInt24uAttributeInteractionInfo); - Map readUnitTestingInt32uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt32uCommandParams); - result.put("readInt32uAttribute", readUnitTestingInt32uAttributeInteractionInfo); - Map readUnitTestingInt40uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt40uCommandParams); - result.put("readInt40uAttribute", readUnitTestingInt40uAttributeInteractionInfo); - Map readUnitTestingInt48uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt48uCommandParams); - result.put("readInt48uAttribute", readUnitTestingInt48uAttributeInteractionInfo); - Map readUnitTestingInt56uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt56uCommandParams); - result.put("readInt56uAttribute", readUnitTestingInt56uAttributeInteractionInfo); - Map readUnitTestingInt64uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt64uCommandParams); - result.put("readInt64uAttribute", readUnitTestingInt64uAttributeInteractionInfo); - Map readUnitTestingInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt8sCommandParams); - result.put("readInt8sAttribute", readUnitTestingInt8sAttributeInteractionInfo); - Map readUnitTestingInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt16sCommandParams); - result.put("readInt16sAttribute", readUnitTestingInt16sAttributeInteractionInfo); - Map readUnitTestingInt24sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt24sCommandParams); - result.put("readInt24sAttribute", readUnitTestingInt24sAttributeInteractionInfo); - Map readUnitTestingInt32sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt32sCommandParams); - result.put("readInt32sAttribute", readUnitTestingInt32sAttributeInteractionInfo); - Map readUnitTestingInt40sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt40sCommandParams); - result.put("readInt40sAttribute", readUnitTestingInt40sAttributeInteractionInfo); - Map readUnitTestingInt48sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt48sCommandParams); - result.put("readInt48sAttribute", readUnitTestingInt48sAttributeInteractionInfo); - Map readUnitTestingInt56sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt56sCommandParams); - result.put("readInt56sAttribute", readUnitTestingInt56sAttributeInteractionInfo); - Map readUnitTestingInt64sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt64sCommandParams); - result.put("readInt64sAttribute", readUnitTestingInt64sAttributeInteractionInfo); - Map readUnitTestingEnum8CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingEnum8CommandParams); - result.put("readEnum8Attribute", readUnitTestingEnum8AttributeInteractionInfo); - Map readUnitTestingEnum16CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingEnum16CommandParams); - result.put("readEnum16Attribute", readUnitTestingEnum16AttributeInteractionInfo); - Map readUnitTestingFloatSingleCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readUnitTestingFloatSingleCommandParams); - result.put("readFloatSingleAttribute", readUnitTestingFloatSingleAttributeInteractionInfo); - Map readUnitTestingFloatDoubleCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readUnitTestingFloatDoubleCommandParams); - result.put("readFloatDoubleAttribute", readUnitTestingFloatDoubleAttributeInteractionInfo); - Map readUnitTestingOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readUnitTestingOctetStringCommandParams); - result.put("readOctetStringAttribute", readUnitTestingOctetStringAttributeInteractionInfo); - Map readUnitTestingListInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingListInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readListInt8uAttribute( - (ChipClusters.UnitTestingCluster.ListInt8uAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListInt8uAttributeCallback(), - readUnitTestingListInt8uCommandParams); - result.put("readListInt8uAttribute", readUnitTestingListInt8uAttributeInteractionInfo); - Map readUnitTestingListOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingListOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readListOctetStringAttribute( - (ChipClusters.UnitTestingCluster.ListOctetStringAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterListOctetStringAttributeCallback(), - readUnitTestingListOctetStringCommandParams); - result.put( - "readListOctetStringAttribute", readUnitTestingListOctetStringAttributeInteractionInfo); - Map readUnitTestingListStructOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingListStructOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readListStructOctetStringAttribute( - (ChipClusters.UnitTestingCluster.ListStructOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterListStructOctetStringAttributeCallback(), - readUnitTestingListStructOctetStringCommandParams); - result.put( - "readListStructOctetStringAttribute", - readUnitTestingListStructOctetStringAttributeInteractionInfo); - Map readUnitTestingLongOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readLongOctetStringAttribute( - (ChipClusters.OctetStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readUnitTestingLongOctetStringCommandParams); - result.put( - "readLongOctetStringAttribute", readUnitTestingLongOctetStringAttributeInteractionInfo); - Map readUnitTestingCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readUnitTestingCharStringCommandParams); - result.put("readCharStringAttribute", readUnitTestingCharStringAttributeInteractionInfo); - Map readUnitTestingLongCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingLongCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readUnitTestingLongCharStringCommandParams); - result.put( - "readLongCharStringAttribute", readUnitTestingLongCharStringAttributeInteractionInfo); - Map readUnitTestingEpochUsCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingEpochUsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingEpochUsCommandParams); - result.put("readEpochUsAttribute", readUnitTestingEpochUsAttributeInteractionInfo); - Map readUnitTestingEpochSCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingEpochSAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingEpochSCommandParams); - result.put("readEpochSAttribute", readUnitTestingEpochSAttributeInteractionInfo); - Map readUnitTestingVendorIdCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingVendorIdCommandParams); - result.put("readVendorIdAttribute", readUnitTestingVendorIdAttributeInteractionInfo); - Map readUnitTestingListNullablesAndOptionalsStructCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readListNullablesAndOptionalsStructAttribute( - (ChipClusters.UnitTestingCluster - .ListNullablesAndOptionalsStructAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterListNullablesAndOptionalsStructAttributeCallback(), - readUnitTestingListNullablesAndOptionalsStructCommandParams); - result.put( - "readListNullablesAndOptionalsStructAttribute", - readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readUnitTestingEnumAttrCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingEnumAttrCommandParams); - result.put("readEnumAttrAttribute", readUnitTestingEnumAttrAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readRangeRestrictedInt8uAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt8uCommandParams); - result.put( - "readRangeRestrictedInt8uAttribute", - readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readRangeRestrictedInt8sAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt8sCommandParams); - result.put( - "readRangeRestrictedInt8sAttribute", - readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readRangeRestrictedInt16uAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt16uCommandParams); - result.put( - "readRangeRestrictedInt16uAttribute", - readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readRangeRestrictedInt16sAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt16sCommandParams); - result.put( - "readRangeRestrictedInt16sAttribute", - readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); - Map readUnitTestingListLongOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingListLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readListLongOctetStringAttribute( - (ChipClusters.UnitTestingCluster.ListLongOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterListLongOctetStringAttributeCallback(), - readUnitTestingListLongOctetStringCommandParams); - result.put( - "readListLongOctetStringAttribute", - readUnitTestingListLongOctetStringAttributeInteractionInfo); - Map readUnitTestingListFabricScopedCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingListFabricScopedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readListFabricScopedAttribute( - (ChipClusters.UnitTestingCluster.ListFabricScopedAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterListFabricScopedAttributeCallback(), - readUnitTestingListFabricScopedCommandParams); - result.put( - "readListFabricScopedAttribute", readUnitTestingListFabricScopedAttributeInteractionInfo); - Map readUnitTestingTimedWriteBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingTimedWriteBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingTimedWriteBooleanCommandParams); - result.put( - "readTimedWriteBooleanAttribute", readUnitTestingTimedWriteBooleanAttributeInteractionInfo); - Map readUnitTestingGeneralErrorBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingGeneralErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readGeneralErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingGeneralErrorBooleanCommandParams); - result.put( - "readGeneralErrorBooleanAttribute", - readUnitTestingGeneralErrorBooleanAttributeInteractionInfo); - Map readUnitTestingClusterErrorBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingClusterErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readClusterErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingClusterErrorBooleanCommandParams); - result.put( - "readClusterErrorBooleanAttribute", - readUnitTestingClusterErrorBooleanAttributeInteractionInfo); - Map readUnitTestingUnsupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingUnsupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingUnsupportedCommandParams); - result.put("readUnsupportedAttribute", readUnitTestingUnsupportedAttributeInteractionInfo); - Map readUnitTestingNullableBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableBooleanAttribute( - (ChipClusters.UnitTestingCluster.NullableBooleanAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableBooleanAttributeCallback(), - readUnitTestingNullableBooleanCommandParams); - result.put( - "readNullableBooleanAttribute", readUnitTestingNullableBooleanAttributeInteractionInfo); - Map readUnitTestingNullableBitmap8CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableBitmap8Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap8AttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableBitmap8AttributeCallback(), - readUnitTestingNullableBitmap8CommandParams); - result.put( - "readNullableBitmap8Attribute", readUnitTestingNullableBitmap8AttributeInteractionInfo); - Map readUnitTestingNullableBitmap16CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableBitmap16Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap16AttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableBitmap16AttributeCallback(), - readUnitTestingNullableBitmap16CommandParams); - result.put( - "readNullableBitmap16Attribute", readUnitTestingNullableBitmap16AttributeInteractionInfo); - Map readUnitTestingNullableBitmap32CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableBitmap32Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap32AttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableBitmap32AttributeCallback(), - readUnitTestingNullableBitmap32CommandParams); - result.put( - "readNullableBitmap32Attribute", readUnitTestingNullableBitmap32AttributeInteractionInfo); - Map readUnitTestingNullableBitmap64CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableBitmap64Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap64AttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableBitmap64AttributeCallback(), - readUnitTestingNullableBitmap64CommandParams); - result.put( - "readNullableBitmap64Attribute", readUnitTestingNullableBitmap64AttributeInteractionInfo); - Map readUnitTestingNullableInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt8uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt8uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8uAttributeCallback(), - readUnitTestingNullableInt8uCommandParams); - result.put("readNullableInt8uAttribute", readUnitTestingNullableInt8uAttributeInteractionInfo); - Map readUnitTestingNullableInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt16uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt16uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16uAttributeCallback(), - readUnitTestingNullableInt16uCommandParams); - result.put( - "readNullableInt16uAttribute", readUnitTestingNullableInt16uAttributeInteractionInfo); - Map readUnitTestingNullableInt24uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt24uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt24uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24uAttributeCallback(), - readUnitTestingNullableInt24uCommandParams); - result.put( - "readNullableInt24uAttribute", readUnitTestingNullableInt24uAttributeInteractionInfo); - Map readUnitTestingNullableInt32uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt32uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt32uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32uAttributeCallback(), - readUnitTestingNullableInt32uCommandParams); - result.put( - "readNullableInt32uAttribute", readUnitTestingNullableInt32uAttributeInteractionInfo); - Map readUnitTestingNullableInt40uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt40uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt40uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40uAttributeCallback(), - readUnitTestingNullableInt40uCommandParams); - result.put( - "readNullableInt40uAttribute", readUnitTestingNullableInt40uAttributeInteractionInfo); - Map readUnitTestingNullableInt48uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt48uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt48uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48uAttributeCallback(), - readUnitTestingNullableInt48uCommandParams); - result.put( - "readNullableInt48uAttribute", readUnitTestingNullableInt48uAttributeInteractionInfo); - Map readUnitTestingNullableInt56uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt56uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt56uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56uAttributeCallback(), - readUnitTestingNullableInt56uCommandParams); - result.put( - "readNullableInt56uAttribute", readUnitTestingNullableInt56uAttributeInteractionInfo); - Map readUnitTestingNullableInt64uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt64uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt64uAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64uAttributeCallback(), - readUnitTestingNullableInt64uCommandParams); - result.put( - "readNullableInt64uAttribute", readUnitTestingNullableInt64uAttributeInteractionInfo); - Map readUnitTestingNullableInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt8sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt8sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8sAttributeCallback(), - readUnitTestingNullableInt8sCommandParams); - result.put("readNullableInt8sAttribute", readUnitTestingNullableInt8sAttributeInteractionInfo); - Map readUnitTestingNullableInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt16sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt16sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16sAttributeCallback(), - readUnitTestingNullableInt16sCommandParams); - result.put( - "readNullableInt16sAttribute", readUnitTestingNullableInt16sAttributeInteractionInfo); - Map readUnitTestingNullableInt24sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt24sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt24sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24sAttributeCallback(), - readUnitTestingNullableInt24sCommandParams); - result.put( - "readNullableInt24sAttribute", readUnitTestingNullableInt24sAttributeInteractionInfo); - Map readUnitTestingNullableInt32sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt32sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt32sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32sAttributeCallback(), - readUnitTestingNullableInt32sCommandParams); - result.put( - "readNullableInt32sAttribute", readUnitTestingNullableInt32sAttributeInteractionInfo); - Map readUnitTestingNullableInt40sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt40sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt40sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40sAttributeCallback(), - readUnitTestingNullableInt40sCommandParams); - result.put( - "readNullableInt40sAttribute", readUnitTestingNullableInt40sAttributeInteractionInfo); - Map readUnitTestingNullableInt48sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt48sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt48sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48sAttributeCallback(), - readUnitTestingNullableInt48sCommandParams); - result.put( - "readNullableInt48sAttribute", readUnitTestingNullableInt48sAttributeInteractionInfo); - Map readUnitTestingNullableInt56sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt56sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt56sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56sAttributeCallback(), - readUnitTestingNullableInt56sCommandParams); - result.put( - "readNullableInt56sAttribute", readUnitTestingNullableInt56sAttributeInteractionInfo); - Map readUnitTestingNullableInt64sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableInt64sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt64sAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64sAttributeCallback(), - readUnitTestingNullableInt64sCommandParams); - result.put( - "readNullableInt64sAttribute", readUnitTestingNullableInt64sAttributeInteractionInfo); - Map readUnitTestingNullableEnum8CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableEnum8Attribute( - (ChipClusters.UnitTestingCluster.NullableEnum8AttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum8AttributeCallback(), - readUnitTestingNullableEnum8CommandParams); - result.put("readNullableEnum8Attribute", readUnitTestingNullableEnum8AttributeInteractionInfo); - Map readUnitTestingNullableEnum16CommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableEnum16Attribute( - (ChipClusters.UnitTestingCluster.NullableEnum16AttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum16AttributeCallback(), - readUnitTestingNullableEnum16CommandParams); - result.put( - "readNullableEnum16Attribute", readUnitTestingNullableEnum16AttributeInteractionInfo); - Map readUnitTestingNullableFloatSingleCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableFloatSingleAttribute( - (ChipClusters.UnitTestingCluster.NullableFloatSingleAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableFloatSingleAttributeCallback(), - readUnitTestingNullableFloatSingleCommandParams); - result.put( - "readNullableFloatSingleAttribute", - readUnitTestingNullableFloatSingleAttributeInteractionInfo); - Map readUnitTestingNullableFloatDoubleCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableFloatDoubleAttribute( - (ChipClusters.UnitTestingCluster.NullableFloatDoubleAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableFloatDoubleAttributeCallback(), - readUnitTestingNullableFloatDoubleCommandParams); - result.put( - "readNullableFloatDoubleAttribute", - readUnitTestingNullableFloatDoubleAttributeInteractionInfo); - Map readUnitTestingNullableOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableOctetStringAttribute( - (ChipClusters.UnitTestingCluster.NullableOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableOctetStringAttributeCallback(), - readUnitTestingNullableOctetStringCommandParams); - result.put( - "readNullableOctetStringAttribute", - readUnitTestingNullableOctetStringAttributeInteractionInfo); - Map readUnitTestingNullableCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableCharStringAttribute( - (ChipClusters.UnitTestingCluster.NullableCharStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableCharStringAttributeCallback(), - readUnitTestingNullableCharStringCommandParams); - result.put( - "readNullableCharStringAttribute", - readUnitTestingNullableCharStringAttributeInteractionInfo); - Map readUnitTestingNullableEnumAttrCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableEnumAttrAttribute( - (ChipClusters.UnitTestingCluster.NullableEnumAttrAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableEnumAttrAttributeCallback(), - readUnitTestingNullableEnumAttrCommandParams); - result.put( - "readNullableEnumAttrAttribute", readUnitTestingNullableEnumAttrAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableRangeRestrictedInt8uAttribute( - (ChipClusters.UnitTestingCluster - .NullableRangeRestrictedInt8uAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableRangeRestrictedInt8uAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt8uCommandParams); - result.put( - "readNullableRangeRestrictedInt8uAttribute", - readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableRangeRestrictedInt8sAttribute( - (ChipClusters.UnitTestingCluster - .NullableRangeRestrictedInt8sAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableRangeRestrictedInt8sAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt8sCommandParams); - result.put( - "readNullableRangeRestrictedInt8sAttribute", - readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableRangeRestrictedInt16uAttribute( - (ChipClusters.UnitTestingCluster - .NullableRangeRestrictedInt16uAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableRangeRestrictedInt16uAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt16uCommandParams); - result.put( - "readNullableRangeRestrictedInt16uAttribute", - readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readNullableRangeRestrictedInt16sAttribute( - (ChipClusters.UnitTestingCluster - .NullableRangeRestrictedInt16sAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterNullableRangeRestrictedInt16sAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt16sCommandParams); - result.put( - "readNullableRangeRestrictedInt16sAttribute", - readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readUnitTestingWriteOnlyInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingWriteOnlyInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readWriteOnlyInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingWriteOnlyInt8uCommandParams); - result.put( - "readWriteOnlyInt8uAttribute", readUnitTestingWriteOnlyInt8uAttributeInteractionInfo); - Map readUnitTestingGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.UnitTestingCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterGeneratedCommandListAttributeCallback(), - readUnitTestingGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readUnitTestingGeneratedCommandListAttributeInteractionInfo); - Map readUnitTestingAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.UnitTestingCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedUnitTestingClusterAcceptedCommandListAttributeCallback(), - readUnitTestingAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readUnitTestingAcceptedCommandListAttributeInteractionInfo); - Map readUnitTestingEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readEventListAttribute( - (ChipClusters.UnitTestingCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterEventListAttributeCallback(), - readUnitTestingEventListCommandParams); - result.put("readEventListAttribute", readUnitTestingEventListAttributeInteractionInfo); - Map readUnitTestingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.UnitTestingCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedUnitTestingClusterAttributeListAttributeCallback(), - readUnitTestingAttributeListCommandParams); - result.put("readAttributeListAttribute", readUnitTestingAttributeListAttributeInteractionInfo); - Map readUnitTestingFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readUnitTestingFeatureMapAttributeInteractionInfo); - Map readUnitTestingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitTestingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readUnitTestingClusterRevisionAttributeInteractionInfo); - - return result; - } - - private static Map readFaultInjectionInteractionInfo() { - Map result = new LinkedHashMap<>(); - Map readFaultInjectionGeneratedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFaultInjectionGeneratedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster) - .readGeneratedCommandListAttribute( - (ChipClusters.FaultInjectionCluster.GeneratedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFaultInjectionClusterGeneratedCommandListAttributeCallback(), - readFaultInjectionGeneratedCommandListCommandParams); - result.put( - "readGeneratedCommandListAttribute", - readFaultInjectionGeneratedCommandListAttributeInteractionInfo); - Map readFaultInjectionAcceptedCommandListCommandParams = - new LinkedHashMap(); - InteractionInfo readFaultInjectionAcceptedCommandListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster) - .readAcceptedCommandListAttribute( - (ChipClusters.FaultInjectionCluster.AcceptedCommandListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFaultInjectionClusterAcceptedCommandListAttributeCallback(), - readFaultInjectionAcceptedCommandListCommandParams); - result.put( - "readAcceptedCommandListAttribute", - readFaultInjectionAcceptedCommandListAttributeInteractionInfo); - Map readFaultInjectionEventListCommandParams = - new LinkedHashMap(); - InteractionInfo readFaultInjectionEventListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster) - .readEventListAttribute( - (ChipClusters.FaultInjectionCluster.EventListAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterEventListAttributeCallback(), - readFaultInjectionEventListCommandParams); - result.put("readEventListAttribute", readFaultInjectionEventListAttributeInteractionInfo); - Map readFaultInjectionAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFaultInjectionAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FaultInjectionCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFaultInjectionClusterAttributeListAttributeCallback(), - readFaultInjectionAttributeListCommandParams); - result.put( - "readAttributeListAttribute", readFaultInjectionAttributeListAttributeInteractionInfo); - Map readFaultInjectionFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readFaultInjectionFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFaultInjectionFeatureMapCommandParams); - result.put("readFeatureMapAttribute", readFaultInjectionFeatureMapAttributeInteractionInfo); - Map readFaultInjectionClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFaultInjectionClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFaultInjectionClusterRevisionCommandParams); - result.put( - "readClusterRevisionAttribute", readFaultInjectionClusterRevisionAttributeInteractionInfo); - - return result; - } - - @SuppressWarnings("serial") - public Map> getReadAttributeMap() { - - return new HashMap>() { - { - put("identify", readIdentifyInteractionInfo()); - put("groups", readGroupsInteractionInfo()); - put("scenes", readScenesInteractionInfo()); - put("onOff", readOnOffInteractionInfo()); - put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo()); - put("levelControl", readLevelControlInteractionInfo()); - put("binaryInputBasic", readBinaryInputBasicInteractionInfo()); - put("pulseWidthModulation", readPulseWidthModulationInteractionInfo()); - put("descriptor", readDescriptorInteractionInfo()); - put("binding", readBindingInteractionInfo()); - put("accessControl", readAccessControlInteractionInfo()); - put("actions", readActionsInteractionInfo()); - put("basicInformation", readBasicInformationInteractionInfo()); - put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo()); - put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo()); - put("localizationConfiguration", readLocalizationConfigurationInteractionInfo()); - put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo()); - put("unitLocalization", readUnitLocalizationInteractionInfo()); - put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo()); - put("powerSource", readPowerSourceInteractionInfo()); - put("generalCommissioning", readGeneralCommissioningInteractionInfo()); - put("networkCommissioning", readNetworkCommissioningInteractionInfo()); - put("diagnosticLogs", readDiagnosticLogsInteractionInfo()); - put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo()); - put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo()); - put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo()); - put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo()); - put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo()); - put("timeSynchronization", readTimeSynchronizationInteractionInfo()); - put("bridgedDeviceBasicInformation", readBridgedDeviceBasicInformationInteractionInfo()); - put("switch", readSwitchInteractionInfo()); - put("administratorCommissioning", readAdministratorCommissioningInteractionInfo()); - put("operationalCredentials", readOperationalCredentialsInteractionInfo()); - put("groupKeyManagement", readGroupKeyManagementInteractionInfo()); - put("fixedLabel", readFixedLabelInteractionInfo()); - put("userLabel", readUserLabelInteractionInfo()); - put("proxyConfiguration", readProxyConfigurationInteractionInfo()); - put("proxyDiscovery", readProxyDiscoveryInteractionInfo()); - put("proxyValid", readProxyValidInteractionInfo()); - put("booleanState", readBooleanStateInteractionInfo()); - put("icdManagement", readIcdManagementInteractionInfo()); - put("modeSelect", readModeSelectInteractionInfo()); - put("temperatureControl", readTemperatureControlInteractionInfo()); - put("refrigeratorAlarm", readRefrigeratorAlarmInteractionInfo()); - put("airQuality", readAirQualityInteractionInfo()); - put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo()); - put("dishwasherAlarm", readDishwasherAlarmInteractionInfo()); - put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo()); - put( - "activatedCarbonFilterMonitoring", - readActivatedCarbonFilterMonitoringInteractionInfo()); - put("ceramicFilterMonitoring", readCeramicFilterMonitoringInteractionInfo()); - put("electrostaticFilterMonitoring", readElectrostaticFilterMonitoringInteractionInfo()); - put("uvFilterMonitoring", readUvFilterMonitoringInteractionInfo()); - put("ionizingFilterMonitoring", readIonizingFilterMonitoringInteractionInfo()); - put("zeoliteFilterMonitoring", readZeoliteFilterMonitoringInteractionInfo()); - put("ozoneFilterMonitoring", readOzoneFilterMonitoringInteractionInfo()); - put("waterTankMonitoring", readWaterTankMonitoringInteractionInfo()); - put("fuelTankMonitoring", readFuelTankMonitoringInteractionInfo()); - put("inkCartridgeMonitoring", readInkCartridgeMonitoringInteractionInfo()); - put("tonerCartridgeMonitoring", readTonerCartridgeMonitoringInteractionInfo()); - put("doorLock", readDoorLockInteractionInfo()); - put("windowCovering", readWindowCoveringInteractionInfo()); - put("barrierControl", readBarrierControlInteractionInfo()); - put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo()); - put("thermostat", readThermostatInteractionInfo()); - put("fanControl", readFanControlInteractionInfo()); - put( - "thermostatUserInterfaceConfiguration", - readThermostatUserInterfaceConfigurationInteractionInfo()); - put("colorControl", readColorControlInteractionInfo()); - put("ballastConfiguration", readBallastConfigurationInteractionInfo()); - put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo()); - put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo()); - put("pressureMeasurement", readPressureMeasurementInteractionInfo()); - put("flowMeasurement", readFlowMeasurementInteractionInfo()); - put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo()); - put("occupancySensing", readOccupancySensingInteractionInfo()); - put("wakeOnLan", readWakeOnLanInteractionInfo()); - put("channel", readChannelInteractionInfo()); - put("targetNavigator", readTargetNavigatorInteractionInfo()); - put("mediaPlayback", readMediaPlaybackInteractionInfo()); - put("mediaInput", readMediaInputInteractionInfo()); - put("lowPower", readLowPowerInteractionInfo()); - put("keypadInput", readKeypadInputInteractionInfo()); - put("contentLauncher", readContentLauncherInteractionInfo()); - put("audioOutput", readAudioOutputInteractionInfo()); - put("applicationLauncher", readApplicationLauncherInteractionInfo()); - put("applicationBasic", readApplicationBasicInteractionInfo()); - put("accountLogin", readAccountLoginInteractionInfo()); - put("electricalMeasurement", readElectricalMeasurementInteractionInfo()); - put("unitTesting", readUnitTestingInteractionInfo()); - put("faultInjection", readFaultInjectionInteractionInfo()); - } - }; - } + private static Map readIdentifyInteractionInfo() { + Map result = new LinkedHashMap<>();Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams + ); + result.put("readIdentifyTimeAttribute", readIdentifyIdentifyTimeAttributeInteractionInfo); + Map readIdentifyIdentifyTypeCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readIdentifyTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTypeCommandParams + ); + result.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.IdentifyCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIdentifyClusterGeneratedCommandListAttributeCallback(), + readIdentifyGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readIdentifyGeneratedCommandListAttributeInteractionInfo); + Map readIdentifyAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.IdentifyCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIdentifyClusterAcceptedCommandListAttributeCallback(), + readIdentifyAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readIdentifyAcceptedCommandListAttributeInteractionInfo); + Map readIdentifyEventListCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readEventListAttribute( + (ChipClusters.IdentifyCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIdentifyClusterEventListAttributeCallback(), + readIdentifyEventListCommandParams + ); + result.put("readEventListAttribute", readIdentifyEventListAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( + (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), + readIdentifyAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIdentifyFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readIdentifyFeatureMapAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readGroupsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readGroupsNameSupportCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams + ); + result.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.GroupsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupsClusterGeneratedCommandListAttributeCallback(), + readGroupsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readGroupsGeneratedCommandListAttributeInteractionInfo); + Map readGroupsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.GroupsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupsClusterAcceptedCommandListAttributeCallback(), + readGroupsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readGroupsAcceptedCommandListAttributeInteractionInfo); + Map readGroupsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readEventListAttribute( + (ChipClusters.GroupsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupsClusterEventListAttributeCallback(), + readGroupsEventListCommandParams + ); + result.put("readEventListAttribute", readGroupsEventListAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( + (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), + readGroupsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGroupsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readGroupsFeatureMapAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readScenesInteractionInfo() { + Map result = new LinkedHashMap<>();Map readScenesSceneCountCommandParams = new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams + ); + result.put("readSceneCountAttribute", readScenesSceneCountAttributeInteractionInfo); + Map readScenesCurrentSceneCommandParams = new LinkedHashMap(); + InteractionInfo readScenesCurrentSceneAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readCurrentSceneAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesCurrentSceneCommandParams + ); + result.put("readCurrentSceneAttribute", readScenesCurrentSceneAttributeInteractionInfo); + Map readScenesCurrentGroupCommandParams = new LinkedHashMap(); + InteractionInfo readScenesCurrentGroupAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readCurrentGroupAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesCurrentGroupCommandParams + ); + result.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); + Map readScenesSceneValidCommandParams = new LinkedHashMap(); + InteractionInfo readScenesSceneValidAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readSceneValidAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readScenesSceneValidCommandParams + ); + result.put("readSceneValidAttribute", readScenesSceneValidAttributeInteractionInfo); + Map readScenesNameSupportCommandParams = new LinkedHashMap(); + InteractionInfo readScenesNameSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readNameSupportAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesNameSupportCommandParams + ); + result.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesLastConfiguredByCommandParams = new LinkedHashMap(); + InteractionInfo readScenesLastConfiguredByAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readLastConfiguredByAttribute( + (ChipClusters.ScenesCluster.LastConfiguredByAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterLastConfiguredByAttributeCallback(), + readScenesLastConfiguredByCommandParams + ); + result.put("readLastConfiguredByAttribute", readScenesLastConfiguredByAttributeInteractionInfo); + Map readScenesGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readScenesGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ScenesCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterGeneratedCommandListAttributeCallback(), + readScenesGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readScenesGeneratedCommandListAttributeInteractionInfo); + Map readScenesAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readScenesAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ScenesCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterAcceptedCommandListAttributeCallback(), + readScenesAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readScenesAcceptedCommandListAttributeInteractionInfo); + Map readScenesEventListCommandParams = new LinkedHashMap(); + InteractionInfo readScenesEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readEventListAttribute( + (ChipClusters.ScenesCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterEventListAttributeCallback(), + readScenesEventListCommandParams + ); + result.put("readEventListAttribute", readScenesEventListAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( + (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), + readScenesAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readScenesFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readScenesFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readScenesFeatureMapAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOnOffInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOnOffOnOffCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOnOffOnOffCommandParams + ); + result.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); + Map readOnOffGlobalSceneControlCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readGlobalSceneControlAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOnOffGlobalSceneControlCommandParams + ); + result.put("readGlobalSceneControlAttribute", readOnOffGlobalSceneControlAttributeInteractionInfo); + Map readOnOffOnTimeCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffOnTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readOnTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffOnTimeCommandParams + ); + result.put("readOnTimeAttribute", readOnOffOnTimeAttributeInteractionInfo); + Map readOnOffOffWaitTimeCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffOffWaitTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readOffWaitTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffOffWaitTimeCommandParams + ); + result.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( + (ChipClusters.OnOffCluster.StartUpOnOffAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterStartUpOnOffAttributeCallback(), + readOnOffStartUpOnOffCommandParams + ); + result.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OnOffCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterGeneratedCommandListAttributeCallback(), + readOnOffGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOnOffGeneratedCommandListAttributeInteractionInfo); + Map readOnOffAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OnOffCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterAcceptedCommandListAttributeCallback(), + readOnOffAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOnOffAcceptedCommandListAttributeInteractionInfo); + Map readOnOffEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readEventListAttribute( + (ChipClusters.OnOffCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterEventListAttributeCallback(), + readOnOffEventListCommandParams + ); + result.put("readEventListAttribute", readOnOffEventListAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( + (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), + readOnOffAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); + Map readOnOffFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOnOffFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOnOffFeatureMapAttributeInteractionInfo); + Map readOnOffClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOnOffSwitchConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams + ); + result.put("readSwitchTypeAttribute", readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo); + Map readOnOffSwitchConfigurationSwitchActionsCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchActionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchActionsCommandParams + ); + result.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map readOnOffSwitchConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterGeneratedCommandListAttributeCallback(), + readOnOffSwitchConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAcceptedCommandListAttributeCallback(), + readOnOffSwitchConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterEventListAttributeCallback(), + readOnOffSwitchConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readOnOffSwitchConfigurationEventListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOnOffSwitchConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readLevelControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.CurrentLevelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterCurrentLevelAttributeCallback(), + readLevelControlCurrentLevelCommandParams + ); + result.put("readCurrentLevelAttribute", readLevelControlCurrentLevelAttributeInteractionInfo); + Map readLevelControlRemainingTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlRemainingTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readRemainingTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlRemainingTimeCommandParams + ); + result.put("readRemainingTimeAttribute", readLevelControlRemainingTimeAttributeInteractionInfo); + Map readLevelControlMinLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlMinLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readMinLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMinLevelCommandParams + ); + result.put("readMinLevelAttribute", readLevelControlMinLevelAttributeInteractionInfo); + Map readLevelControlMaxLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlMaxLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readMaxLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMaxLevelCommandParams + ); + result.put("readMaxLevelAttribute", readLevelControlMaxLevelAttributeInteractionInfo); + Map readLevelControlCurrentFrequencyCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlCurrentFrequencyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readCurrentFrequencyAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentFrequencyCommandParams + ); + result.put("readCurrentFrequencyAttribute", readLevelControlCurrentFrequencyAttributeInteractionInfo); + Map readLevelControlMinFrequencyCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlMinFrequencyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readMinFrequencyAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMinFrequencyCommandParams + ); + result.put("readMinFrequencyAttribute", readLevelControlMinFrequencyAttributeInteractionInfo); + Map readLevelControlMaxFrequencyCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlMaxFrequencyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readMaxFrequencyAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMaxFrequencyCommandParams + ); + result.put("readMaxFrequencyAttribute", readLevelControlMaxFrequencyAttributeInteractionInfo); + Map readLevelControlOptionsCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOptionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOptionsCommandParams + ); + result.put("readOptionsAttribute", readLevelControlOptionsAttributeInteractionInfo); + Map readLevelControlOnOffTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnOffTransitionTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnOffTransitionTimeCommandParams + ); + result.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( + (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterOnLevelAttributeCallback(), + readLevelControlOnLevelCommandParams + ); + result.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterOnTransitionTimeAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams + ); + result.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterOffTransitionTimeAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams + ); + result.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( + (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterDefaultMoveRateAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams + ); + result.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterStartUpCurrentLevelAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams + ); + result.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.LevelControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterGeneratedCommandListAttributeCallback(), + readLevelControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readLevelControlGeneratedCommandListAttributeInteractionInfo); + Map readLevelControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.LevelControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterAcceptedCommandListAttributeCallback(), + readLevelControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readLevelControlAcceptedCommandListAttributeInteractionInfo); + Map readLevelControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readEventListAttribute( + (ChipClusters.LevelControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterEventListAttributeCallback(), + readLevelControlEventListCommandParams + ); + result.put("readEventListAttribute", readLevelControlEventListAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); + Map readLevelControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLevelControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readLevelControlFeatureMapAttributeInteractionInfo); + Map readLevelControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBinaryInputBasicInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBinaryInputBasicActiveTextCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicActiveTextAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readActiveTextAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBinaryInputBasicActiveTextCommandParams + ); + result.put("readActiveTextAttribute", readBinaryInputBasicActiveTextAttributeInteractionInfo); + Map readBinaryInputBasicDescriptionCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readDescriptionAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBinaryInputBasicDescriptionCommandParams + ); + result.put("readDescriptionAttribute", readBinaryInputBasicDescriptionAttributeInteractionInfo); + Map readBinaryInputBasicInactiveTextCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicInactiveTextAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readInactiveTextAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBinaryInputBasicInactiveTextCommandParams + ); + result.put("readInactiveTextAttribute", readBinaryInputBasicInactiveTextAttributeInteractionInfo); + Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBinaryInputBasicOutOfServiceCommandParams + ); + result.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPolarityCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPolarityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readPolarityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicPolarityCommandParams + ); + result.put("readPolarityAttribute", readBinaryInputBasicPolarityAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBinaryInputBasicPresentValueCommandParams + ); + result.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicReliabilityCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicReliabilityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readReliabilityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicReliabilityCommandParams + ); + result.put("readReliabilityAttribute", readBinaryInputBasicReliabilityAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams + ); + result.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicApplicationTypeCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicApplicationTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readApplicationTypeAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBinaryInputBasicApplicationTypeCommandParams + ); + result.put("readApplicationTypeAttribute", readBinaryInputBasicApplicationTypeAttributeInteractionInfo); + Map readBinaryInputBasicGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BinaryInputBasicCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterGeneratedCommandListAttributeCallback(), + readBinaryInputBasicGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo); + Map readBinaryInputBasicAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BinaryInputBasicCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAcceptedCommandListAttributeCallback(), + readBinaryInputBasicAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo); + Map readBinaryInputBasicEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readEventListAttribute( + (ChipClusters.BinaryInputBasicCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterEventListAttributeCallback(), + readBinaryInputBasicEventListCommandParams + ); + result.put("readEventListAttribute", readBinaryInputBasicEventListAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( + (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBinaryInputBasicFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBinaryInputBasicFeatureMapAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPulseWidthModulationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPulseWidthModulationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.PulseWidthModulationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterGeneratedCommandListAttributeCallback(), + readPulseWidthModulationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo); + Map readPulseWidthModulationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.PulseWidthModulationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterAcceptedCommandListAttributeCallback(), + readPulseWidthModulationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo); + Map readPulseWidthModulationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPulseWidthModulationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster).readEventListAttribute( + (ChipClusters.PulseWidthModulationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterEventListAttributeCallback(), + readPulseWidthModulationEventListCommandParams + ); + result.put("readEventListAttribute", readPulseWidthModulationEventListAttributeInteractionInfo); + Map readPulseWidthModulationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPulseWidthModulationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster).readAttributeListAttribute( + (ChipClusters.PulseWidthModulationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterAttributeListAttributeCallback(), + readPulseWidthModulationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPulseWidthModulationAttributeListAttributeInteractionInfo); + Map readPulseWidthModulationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPulseWidthModulationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPulseWidthModulationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPulseWidthModulationFeatureMapAttributeInteractionInfo); + Map readPulseWidthModulationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPulseWidthModulationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPulseWidthModulationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPulseWidthModulationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readDescriptorInteractionInfo() { + Map result = new LinkedHashMap<>();Map readDescriptorDeviceTypeListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorDeviceTypeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readDeviceTypeListAttribute( + (ChipClusters.DescriptorCluster.DeviceTypeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceTypeListAttributeCallback(), + readDescriptorDeviceTypeListCommandParams + ); + result.put("readDeviceTypeListAttribute", readDescriptorDeviceTypeListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( + (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), + readDescriptorServerListCommandParams + ); + result.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); + Map readDescriptorClientListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorClientListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readClientListAttribute( + (ChipClusters.DescriptorCluster.ClientListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterClientListAttributeCallback(), + readDescriptorClientListCommandParams + ); + result.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); + Map readDescriptorPartsListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorPartsListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readPartsListAttribute( + (ChipClusters.DescriptorCluster.PartsListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterPartsListAttributeCallback(), + readDescriptorPartsListCommandParams + ); + result.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.DescriptorCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterGeneratedCommandListAttributeCallback(), + readDescriptorGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readDescriptorGeneratedCommandListAttributeInteractionInfo); + Map readDescriptorAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.DescriptorCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterAcceptedCommandListAttributeCallback(), + readDescriptorAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readDescriptorAcceptedCommandListAttributeInteractionInfo); + Map readDescriptorEventListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readEventListAttribute( + (ChipClusters.DescriptorCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterEventListAttributeCallback(), + readDescriptorEventListCommandParams + ); + result.put("readEventListAttribute", readDescriptorEventListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( + (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), + readDescriptorAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDescriptorFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readDescriptorFeatureMapAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBindingInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBindingBindingCommandParams = new LinkedHashMap(); + InteractionInfo readBindingBindingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readBindingAttribute( + (ChipClusters.BindingCluster.BindingAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterBindingAttributeCallback(), + readBindingBindingCommandParams + ); + result.put("readBindingAttribute", readBindingBindingAttributeInteractionInfo); + Map readBindingGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBindingGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BindingCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterGeneratedCommandListAttributeCallback(), + readBindingGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBindingGeneratedCommandListAttributeInteractionInfo); + Map readBindingAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBindingAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BindingCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterAcceptedCommandListAttributeCallback(), + readBindingAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBindingAcceptedCommandListAttributeInteractionInfo); + Map readBindingEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBindingEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readEventListAttribute( + (ChipClusters.BindingCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterEventListAttributeCallback(), + readBindingEventListCommandParams + ); + result.put("readEventListAttribute", readBindingEventListAttributeInteractionInfo); + Map readBindingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( + (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), + readBindingAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBindingFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBindingFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBindingFeatureMapAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readAccessControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readAccessControlAclCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlAclAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readAclAttribute( + (ChipClusters.AccessControlCluster.AclAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterAclAttributeCallback(), + readAccessControlAclCommandParams + ); + result.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); + Map readAccessControlExtensionCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlExtensionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readExtensionAttribute( + (ChipClusters.AccessControlCluster.ExtensionAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterExtensionAttributeCallback(), + readAccessControlExtensionCommandParams + ); + result.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlSubjectsPerAccessControlEntryCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readSubjectsPerAccessControlEntryAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlSubjectsPerAccessControlEntryCommandParams + ); + result.put("readSubjectsPerAccessControlEntryAttribute", readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo); + Map readAccessControlTargetsPerAccessControlEntryCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readTargetsPerAccessControlEntryAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlTargetsPerAccessControlEntryCommandParams + ); + result.put("readTargetsPerAccessControlEntryAttribute", readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo); + Map readAccessControlAccessControlEntriesPerFabricCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readAccessControlEntriesPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlAccessControlEntriesPerFabricCommandParams + ); + result.put("readAccessControlEntriesPerFabricAttribute", readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo); + Map readAccessControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.AccessControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterGeneratedCommandListAttributeCallback(), + readAccessControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readAccessControlGeneratedCommandListAttributeInteractionInfo); + Map readAccessControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.AccessControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterAcceptedCommandListAttributeCallback(), + readAccessControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readAccessControlAcceptedCommandListAttributeInteractionInfo); + Map readAccessControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readEventListAttribute( + (ChipClusters.AccessControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterEventListAttributeCallback(), + readAccessControlEventListCommandParams + ); + result.put("readEventListAttribute", readAccessControlEventListAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAccessControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readAccessControlFeatureMapAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readActionsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readActionsActionListCommandParams = new LinkedHashMap(); + InteractionInfo readActionsActionListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readActionListAttribute( + (ChipClusters.ActionsCluster.ActionListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterActionListAttributeCallback(), + readActionsActionListCommandParams + ); + result.put("readActionListAttribute", readActionsActionListAttributeInteractionInfo); + Map readActionsEndpointListsCommandParams = new LinkedHashMap(); + InteractionInfo readActionsEndpointListsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readEndpointListsAttribute( + (ChipClusters.ActionsCluster.EndpointListsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterEndpointListsAttributeCallback(), + readActionsEndpointListsCommandParams + ); + result.put("readEndpointListsAttribute", readActionsEndpointListsAttributeInteractionInfo); + Map readActionsSetupURLCommandParams = new LinkedHashMap(); + InteractionInfo readActionsSetupURLAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readSetupURLAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readActionsSetupURLCommandParams + ); + result.put("readSetupURLAttribute", readActionsSetupURLAttributeInteractionInfo); + Map readActionsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readActionsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ActionsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterGeneratedCommandListAttributeCallback(), + readActionsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readActionsGeneratedCommandListAttributeInteractionInfo); + Map readActionsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readActionsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ActionsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterAcceptedCommandListAttributeCallback(), + readActionsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readActionsAcceptedCommandListAttributeInteractionInfo); + Map readActionsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readActionsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readEventListAttribute( + (ChipClusters.ActionsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterEventListAttributeCallback(), + readActionsEventListCommandParams + ); + result.put("readEventListAttribute", readActionsEventListAttributeInteractionInfo); + Map readActionsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readActionsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readAttributeListAttribute( + (ChipClusters.ActionsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterAttributeListAttributeCallback(), + readActionsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readActionsAttributeListAttributeInteractionInfo); + Map readActionsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readActionsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readActionsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readActionsFeatureMapAttributeInteractionInfo); + Map readActionsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActionsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readActionsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBasicInformationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBasicInformationDataModelRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationDataModelRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readDataModelRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationDataModelRevisionCommandParams + ); + result.put("readDataModelRevisionAttribute", readBasicInformationDataModelRevisionAttributeInteractionInfo); + Map readBasicInformationVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readVendorNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationVendorNameCommandParams + ); + result.put("readVendorNameAttribute", readBasicInformationVendorNameAttributeInteractionInfo); + Map readBasicInformationVendorIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationVendorIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readVendorIDAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationVendorIDCommandParams + ); + result.put("readVendorIDAttribute", readBasicInformationVendorIDAttributeInteractionInfo); + Map readBasicInformationProductNameCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationProductNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readProductNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationProductNameCommandParams + ); + result.put("readProductNameAttribute", readBasicInformationProductNameAttributeInteractionInfo); + Map readBasicInformationProductIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationProductIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readProductIDAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationProductIDCommandParams + ); + result.put("readProductIDAttribute", readBasicInformationProductIDAttributeInteractionInfo); + Map readBasicInformationNodeLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readNodeLabelAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationNodeLabelCommandParams + ); + result.put("readNodeLabelAttribute", readBasicInformationNodeLabelAttributeInteractionInfo); + Map readBasicInformationLocationCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationLocationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readLocationAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationLocationCommandParams + ); + result.put("readLocationAttribute", readBasicInformationLocationAttributeInteractionInfo); + Map readBasicInformationHardwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationHardwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readHardwareVersionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationHardwareVersionCommandParams + ); + result.put("readHardwareVersionAttribute", readBasicInformationHardwareVersionAttributeInteractionInfo); + Map readBasicInformationHardwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationHardwareVersionStringCommandParams + ); + result.put("readHardwareVersionStringAttribute", readBasicInformationHardwareVersionStringAttributeInteractionInfo); + Map readBasicInformationSoftwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationSoftwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readSoftwareVersionAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBasicInformationSoftwareVersionCommandParams + ); + result.put("readSoftwareVersionAttribute", readBasicInformationSoftwareVersionAttributeInteractionInfo); + Map readBasicInformationSoftwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationSoftwareVersionStringCommandParams + ); + result.put("readSoftwareVersionStringAttribute", readBasicInformationSoftwareVersionStringAttributeInteractionInfo); + Map readBasicInformationManufacturingDateCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationManufacturingDateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationManufacturingDateCommandParams + ); + result.put("readManufacturingDateAttribute", readBasicInformationManufacturingDateAttributeInteractionInfo); + Map readBasicInformationPartNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationPartNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readPartNumberAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationPartNumberCommandParams + ); + result.put("readPartNumberAttribute", readBasicInformationPartNumberAttributeInteractionInfo); + Map readBasicInformationProductURLCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationProductURLAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readProductURLAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationProductURLCommandParams + ); + result.put("readProductURLAttribute", readBasicInformationProductURLAttributeInteractionInfo); + Map readBasicInformationProductLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationProductLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readProductLabelAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationProductLabelCommandParams + ); + result.put("readProductLabelAttribute", readBasicInformationProductLabelAttributeInteractionInfo); + Map readBasicInformationSerialNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationSerialNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readSerialNumberAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationSerialNumberCommandParams + ); + result.put("readSerialNumberAttribute", readBasicInformationSerialNumberAttributeInteractionInfo); + Map readBasicInformationLocalConfigDisabledCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readLocalConfigDisabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBasicInformationLocalConfigDisabledCommandParams + ); + result.put("readLocalConfigDisabledAttribute", readBasicInformationLocalConfigDisabledAttributeInteractionInfo); + Map readBasicInformationReachableCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationReachableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readReachableAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBasicInformationReachableCommandParams + ); + result.put("readReachableAttribute", readBasicInformationReachableAttributeInteractionInfo); + Map readBasicInformationUniqueIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationUniqueIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readUniqueIDAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationUniqueIDCommandParams + ); + result.put("readUniqueIDAttribute", readBasicInformationUniqueIDAttributeInteractionInfo); + Map readBasicInformationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BasicInformationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBasicInformationClusterGeneratedCommandListAttributeCallback(), + readBasicInformationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBasicInformationGeneratedCommandListAttributeInteractionInfo); + Map readBasicInformationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BasicInformationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBasicInformationClusterAcceptedCommandListAttributeCallback(), + readBasicInformationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBasicInformationAcceptedCommandListAttributeInteractionInfo); + Map readBasicInformationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readEventListAttribute( + (ChipClusters.BasicInformationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBasicInformationClusterEventListAttributeCallback(), + readBasicInformationEventListCommandParams + ); + result.put("readEventListAttribute", readBasicInformationEventListAttributeInteractionInfo); + Map readBasicInformationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readAttributeListAttribute( + (ChipClusters.BasicInformationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBasicInformationClusterAttributeListAttributeCallback(), + readBasicInformationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBasicInformationAttributeListAttributeInteractionInfo); + Map readBasicInformationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBasicInformationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBasicInformationFeatureMapAttributeInteractionInfo); + Map readBasicInformationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInformationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBasicInformationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOtaSoftwareUpdateProviderInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterGeneratedCommandListAttributeCallback(), + readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAcceptedCommandListAttributeCallback(), + readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readEventListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterEventListAttributeCallback(), + readOtaSoftwareUpdateProviderEventListCommandParams + ); + result.put("readEventListAttribute", readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOtaSoftwareUpdateProviderFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOtaSoftwareUpdateRequestorInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readDefaultOTAProvidersAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOTAProvidersAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterDefaultOTAProvidersAttributeCallback(), + readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams + ); + result.put("readDefaultOTAProvidersAttribute", readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdatePossibleAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams + ); + result.put("readUpdatePossibleAttribute", readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdateStateCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateCommandParams + ); + result.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterUpdateStateProgressAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams + ); + result.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterGeneratedCommandListAttributeCallback(), + readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAcceptedCommandListAttributeCallback(), + readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readEventListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterEventListAttributeCallback(), + readOtaSoftwareUpdateRequestorEventListCommandParams + ); + result.put("readEventListAttribute", readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOtaSoftwareUpdateRequestorFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readLocalizationConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readLocalizationConfigurationActiveLocaleCommandParams + ); + result.put("readActiveLocaleAttribute", readLocalizationConfigurationActiveLocaleAttributeInteractionInfo); + Map readLocalizationConfigurationSupportedLocalesCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readSupportedLocalesAttribute( + (ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback(), + readLocalizationConfigurationSupportedLocalesCommandParams + ); + result.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map readLocalizationConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.LocalizationConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterGeneratedCommandListAttributeCallback(), + readLocalizationConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readLocalizationConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.LocalizationConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterAcceptedCommandListAttributeCallback(), + readLocalizationConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readLocalizationConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.LocalizationConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterEventListAttributeCallback(), + readLocalizationConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readLocalizationConfigurationEventListAttributeInteractionInfo); + Map readLocalizationConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.LocalizationConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterAttributeListAttributeCallback(), + readLocalizationConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readLocalizationConfigurationAttributeListAttributeInteractionInfo); + Map readLocalizationConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLocalizationConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readLocalizationConfigurationFeatureMapAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTimeFormatLocalizationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams + ); + result.put("readHourFormatAttribute", readTimeFormatLocalizationHourFormatAttributeInteractionInfo); + Map readTimeFormatLocalizationActiveCalendarTypeCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readActiveCalendarTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationActiveCalendarTypeCommandParams + ); + result.put("readActiveCalendarTypeAttribute", readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); + Map readTimeFormatLocalizationSupportedCalendarTypesCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readSupportedCalendarTypesAttribute( + (ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback(), + readTimeFormatLocalizationSupportedCalendarTypesCommandParams + ); + result.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TimeFormatLocalizationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterGeneratedCommandListAttributeCallback(), + readTimeFormatLocalizationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo); + Map readTimeFormatLocalizationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TimeFormatLocalizationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterAcceptedCommandListAttributeCallback(), + readTimeFormatLocalizationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo); + Map readTimeFormatLocalizationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readEventListAttribute( + (ChipClusters.TimeFormatLocalizationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterEventListAttributeCallback(), + readTimeFormatLocalizationEventListCommandParams + ); + result.put("readEventListAttribute", readTimeFormatLocalizationEventListAttributeInteractionInfo); + Map readTimeFormatLocalizationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readAttributeListAttribute( + (ChipClusters.TimeFormatLocalizationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterAttributeListAttributeCallback(), + readTimeFormatLocalizationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTimeFormatLocalizationAttributeListAttributeInteractionInfo); + Map readTimeFormatLocalizationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTimeFormatLocalizationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTimeFormatLocalizationFeatureMapAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readUnitLocalizationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams + ); + result.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.UnitLocalizationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterGeneratedCommandListAttributeCallback(), + readUnitLocalizationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readUnitLocalizationGeneratedCommandListAttributeInteractionInfo); + Map readUnitLocalizationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.UnitLocalizationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterAcceptedCommandListAttributeCallback(), + readUnitLocalizationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readUnitLocalizationAcceptedCommandListAttributeInteractionInfo); + Map readUnitLocalizationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readEventListAttribute( + (ChipClusters.UnitLocalizationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterEventListAttributeCallback(), + readUnitLocalizationEventListCommandParams + ); + result.put("readEventListAttribute", readUnitLocalizationEventListAttributeInteractionInfo); + Map readUnitLocalizationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readAttributeListAttribute( + (ChipClusters.UnitLocalizationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterAttributeListAttributeCallback(), + readUnitLocalizationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readUnitLocalizationAttributeListAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitLocalizationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readUnitLocalizationFeatureMapAttributeInteractionInfo); + Map readUnitLocalizationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPowerSourceConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPowerSourceConfigurationSourcesCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationSourcesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readSourcesAttribute( + (ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback(), + readPowerSourceConfigurationSourcesCommandParams + ); + result.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map readPowerSourceConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterGeneratedCommandListAttributeCallback(), + readPowerSourceConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readPowerSourceConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAcceptedCommandListAttributeCallback(), + readPowerSourceConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readPowerSourceConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterEventListAttributeCallback(), + readPowerSourceConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readPowerSourceConfigurationEventListAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPowerSourceConfigurationFeatureMapAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPowerSourceInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPowerSourceStatusCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams + ); + result.put("readStatusAttribute", readPowerSourceStatusAttributeInteractionInfo); + Map readPowerSourceOrderCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceOrderAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readOrderAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceOrderCommandParams + ); + result.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); + Map readPowerSourceDescriptionCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readDescriptionAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceDescriptionCommandParams + ); + result.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceWiredAssessedInputVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredAssessedInputVoltageAttribute( + (ChipClusters.PowerSourceCluster.WiredAssessedInputVoltageAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterWiredAssessedInputVoltageAttributeCallback(), + readPowerSourceWiredAssessedInputVoltageCommandParams + ); + result.put("readWiredAssessedInputVoltageAttribute", readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo); + Map readPowerSourceWiredAssessedInputFrequencyCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredAssessedInputFrequencyAttribute( + (ChipClusters.PowerSourceCluster.WiredAssessedInputFrequencyAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterWiredAssessedInputFrequencyAttributeCallback(), + readPowerSourceWiredAssessedInputFrequencyCommandParams + ); + result.put("readWiredAssessedInputFrequencyAttribute", readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo); + Map readPowerSourceWiredCurrentTypeCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredCurrentTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredCurrentTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceWiredCurrentTypeCommandParams + ); + result.put("readWiredCurrentTypeAttribute", readPowerSourceWiredCurrentTypeAttributeInteractionInfo); + Map readPowerSourceWiredAssessedCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredAssessedCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredAssessedCurrentAttribute( + (ChipClusters.PowerSourceCluster.WiredAssessedCurrentAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterWiredAssessedCurrentAttributeCallback(), + readPowerSourceWiredAssessedCurrentCommandParams + ); + result.put("readWiredAssessedCurrentAttribute", readPowerSourceWiredAssessedCurrentAttributeInteractionInfo); + Map readPowerSourceWiredNominalVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredNominalVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredNominalVoltageAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceWiredNominalVoltageCommandParams + ); + result.put("readWiredNominalVoltageAttribute", readPowerSourceWiredNominalVoltageAttributeInteractionInfo); + Map readPowerSourceWiredMaximumCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredMaximumCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredMaximumCurrentAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceWiredMaximumCurrentCommandParams + ); + result.put("readWiredMaximumCurrentAttribute", readPowerSourceWiredMaximumCurrentAttributeInteractionInfo); + Map readPowerSourceWiredPresentCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceWiredPresentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readWiredPresentAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceWiredPresentCommandParams + ); + result.put("readWiredPresentAttribute", readPowerSourceWiredPresentAttributeInteractionInfo); + Map readPowerSourceActiveWiredFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceActiveWiredFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readActiveWiredFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveWiredFaultsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveWiredFaultsAttributeCallback(), + readPowerSourceActiveWiredFaultsCommandParams + ); + result.put("readActiveWiredFaultsAttribute", readPowerSourceActiveWiredFaultsAttributeInteractionInfo); + Map readPowerSourceBatVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatVoltageAttribute( + (ChipClusters.PowerSourceCluster.BatVoltageAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatVoltageAttributeCallback(), + readPowerSourceBatVoltageCommandParams + ); + result.put("readBatVoltageAttribute", readPowerSourceBatVoltageAttributeInteractionInfo); + Map readPowerSourceBatPercentRemainingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatPercentRemainingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatPercentRemainingAttribute( + (ChipClusters.PowerSourceCluster.BatPercentRemainingAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatPercentRemainingAttributeCallback(), + readPowerSourceBatPercentRemainingCommandParams + ); + result.put("readBatPercentRemainingAttribute", readPowerSourceBatPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatTimeRemainingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatTimeRemainingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatTimeRemainingAttribute( + (ChipClusters.PowerSourceCluster.BatTimeRemainingAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatTimeRemainingAttributeCallback(), + readPowerSourceBatTimeRemainingCommandParams + ); + result.put("readBatTimeRemainingAttribute", readPowerSourceBatTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatChargeLevelCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatChargeLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatChargeLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatChargeLevelCommandParams + ); + result.put("readBatChargeLevelAttribute", readPowerSourceBatChargeLevelAttributeInteractionInfo); + Map readPowerSourceBatReplacementNeededCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatReplacementNeededAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatReplacementNeededAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceBatReplacementNeededCommandParams + ); + result.put("readBatReplacementNeededAttribute", readPowerSourceBatReplacementNeededAttributeInteractionInfo); + Map readPowerSourceBatReplaceabilityCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatReplaceabilityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatReplaceabilityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatReplaceabilityCommandParams + ); + result.put("readBatReplaceabilityAttribute", readPowerSourceBatReplaceabilityAttributeInteractionInfo); + Map readPowerSourceBatPresentCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatPresentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatPresentAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceBatPresentCommandParams + ); + result.put("readBatPresentAttribute", readPowerSourceBatPresentAttributeInteractionInfo); + Map readPowerSourceActiveBatFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readActiveBatFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatFaultsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatFaultsAttributeCallback(), + readPowerSourceActiveBatFaultsCommandParams + ); + result.put("readActiveBatFaultsAttribute", readPowerSourceActiveBatFaultsAttributeInteractionInfo); + Map readPowerSourceBatReplacementDescriptionCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatReplacementDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatReplacementDescriptionAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceBatReplacementDescriptionCommandParams + ); + result.put("readBatReplacementDescriptionAttribute", readPowerSourceBatReplacementDescriptionAttributeInteractionInfo); + Map readPowerSourceBatCommonDesignationCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatCommonDesignationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatCommonDesignationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatCommonDesignationCommandParams + ); + result.put("readBatCommonDesignationAttribute", readPowerSourceBatCommonDesignationAttributeInteractionInfo); + Map readPowerSourceBatANSIDesignationCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatANSIDesignationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatANSIDesignationAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceBatANSIDesignationCommandParams + ); + result.put("readBatANSIDesignationAttribute", readPowerSourceBatANSIDesignationAttributeInteractionInfo); + Map readPowerSourceBatIECDesignationCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatIECDesignationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatIECDesignationAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceBatIECDesignationCommandParams + ); + result.put("readBatIECDesignationAttribute", readPowerSourceBatIECDesignationAttributeInteractionInfo); + Map readPowerSourceBatApprovedChemistryCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatApprovedChemistryAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatApprovedChemistryAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatApprovedChemistryCommandParams + ); + result.put("readBatApprovedChemistryAttribute", readPowerSourceBatApprovedChemistryAttributeInteractionInfo); + Map readPowerSourceBatCapacityCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatCapacityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatCapacityAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceBatCapacityCommandParams + ); + result.put("readBatCapacityAttribute", readPowerSourceBatCapacityAttributeInteractionInfo); + Map readPowerSourceBatQuantityCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatQuantityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatQuantityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatQuantityCommandParams + ); + result.put("readBatQuantityAttribute", readPowerSourceBatQuantityAttributeInteractionInfo); + Map readPowerSourceBatChargeStateCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatChargeStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatChargeStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatChargeStateCommandParams + ); + result.put("readBatChargeStateAttribute", readPowerSourceBatChargeStateAttributeInteractionInfo); + Map readPowerSourceBatTimeToFullChargeCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatTimeToFullChargeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatTimeToFullChargeAttribute( + (ChipClusters.PowerSourceCluster.BatTimeToFullChargeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatTimeToFullChargeAttributeCallback(), + readPowerSourceBatTimeToFullChargeCommandParams + ); + result.put("readBatTimeToFullChargeAttribute", readPowerSourceBatTimeToFullChargeAttributeInteractionInfo); + Map readPowerSourceBatFunctionalWhileChargingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatFunctionalWhileChargingAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceBatFunctionalWhileChargingCommandParams + ); + result.put("readBatFunctionalWhileChargingAttribute", readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo); + Map readPowerSourceBatChargingCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatChargingCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatChargingCurrentAttribute( + (ChipClusters.PowerSourceCluster.BatChargingCurrentAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatChargingCurrentAttributeCallback(), + readPowerSourceBatChargingCurrentCommandParams + ); + result.put("readBatChargingCurrentAttribute", readPowerSourceBatChargingCurrentAttributeInteractionInfo); + Map readPowerSourceActiveBatChargeFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readActiveBatChargeFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatChargeFaultsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatChargeFaultsAttributeCallback(), + readPowerSourceActiveBatChargeFaultsCommandParams + ); + result.put("readActiveBatChargeFaultsAttribute", readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo); + Map readPowerSourceGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.PowerSourceCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterGeneratedCommandListAttributeCallback(), + readPowerSourceGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPowerSourceGeneratedCommandListAttributeInteractionInfo); + Map readPowerSourceAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.PowerSourceCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAcceptedCommandListAttributeCallback(), + readPowerSourceAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPowerSourceAcceptedCommandListAttributeInteractionInfo); + Map readPowerSourceEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readEventListAttribute( + (ChipClusters.PowerSourceCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterEventListAttributeCallback(), + readPowerSourceEventListCommandParams + ); + result.put("readEventListAttribute", readPowerSourceEventListAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( + (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); + Map readPowerSourceFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPowerSourceFeatureMapAttributeInteractionInfo); + Map readPowerSourceClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readGeneralCommissioningInteractionInfo() { + Map result = new LinkedHashMap<>();Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralCommissioningBreadcrumbCommandParams + ); + result.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams + ); + result.put("readRegulatoryConfigAttribute", readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo); + Map readGeneralCommissioningLocationCapabilityCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningLocationCapabilityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readLocationCapabilityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningLocationCapabilityCommandParams + ); + result.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map readGeneralCommissioningSupportsConcurrentConnectionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readSupportsConcurrentConnectionAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readGeneralCommissioningSupportsConcurrentConnectionCommandParams + ); + result.put("readSupportsConcurrentConnectionAttribute", readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo); + Map readGeneralCommissioningGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.GeneralCommissioningCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterGeneratedCommandListAttributeCallback(), + readGeneralCommissioningGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo); + Map readGeneralCommissioningAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.GeneralCommissioningCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAcceptedCommandListAttributeCallback(), + readGeneralCommissioningAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo); + Map readGeneralCommissioningEventListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readEventListAttribute( + (ChipClusters.GeneralCommissioningCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterEventListAttributeCallback(), + readGeneralCommissioningEventListCommandParams + ); + result.put("readEventListAttribute", readGeneralCommissioningEventListAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( + (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralCommissioningFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readGeneralCommissioningFeatureMapAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readNetworkCommissioningInteractionInfo() { + Map result = new LinkedHashMap<>();Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams + ); + result.put("readMaxNetworksAttribute", readNetworkCommissioningMaxNetworksAttributeInteractionInfo); + Map readNetworkCommissioningNetworksCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningNetworksAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readNetworksAttribute( + (ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterNetworksAttributeCallback(), + readNetworkCommissioningNetworksCommandParams + ); + result.put("readNetworksAttribute", readNetworkCommissioningNetworksAttributeInteractionInfo); + Map readNetworkCommissioningScanMaxTimeSecondsCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readScanMaxTimeSecondsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningScanMaxTimeSecondsCommandParams + ); + result.put("readScanMaxTimeSecondsAttribute", readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo); + Map readNetworkCommissioningConnectMaxTimeSecondsCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readConnectMaxTimeSecondsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningConnectMaxTimeSecondsCommandParams + ); + result.put("readConnectMaxTimeSecondsAttribute", readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); + Map readNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readInterfaceEnabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readNetworkCommissioningInterfaceEnabledCommandParams + ); + result.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( + (ChipClusters.NetworkCommissioningCluster.LastNetworkingStatusAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterLastNetworkingStatusAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams + ); + result.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( + (ChipClusters.NetworkCommissioningCluster.LastNetworkIDAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterLastNetworkIDAttributeCallback(), + readNetworkCommissioningLastNetworkIDCommandParams + ); + result.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( + (ChipClusters.NetworkCommissioningCluster.LastConnectErrorValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterLastConnectErrorValueAttributeCallback(), + readNetworkCommissioningLastConnectErrorValueCommandParams + ); + result.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.NetworkCommissioningCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterGeneratedCommandListAttributeCallback(), + readNetworkCommissioningGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo); + Map readNetworkCommissioningAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.NetworkCommissioningCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterAcceptedCommandListAttributeCallback(), + readNetworkCommissioningAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo); + Map readNetworkCommissioningEventListCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readEventListAttribute( + (ChipClusters.NetworkCommissioningCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterEventListAttributeCallback(), + readNetworkCommissioningEventListCommandParams + ); + result.put("readEventListAttribute", readNetworkCommissioningEventListAttributeInteractionInfo); + Map readNetworkCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readAttributeListAttribute( + (ChipClusters.NetworkCommissioningCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterAttributeListAttributeCallback(), + readNetworkCommissioningAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readNetworkCommissioningAttributeListAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNetworkCommissioningFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readNetworkCommissioningFeatureMapAttributeInteractionInfo); + Map readNetworkCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readDiagnosticLogsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readDiagnosticLogsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.DiagnosticLogsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterGeneratedCommandListAttributeCallback(), + readDiagnosticLogsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo); + Map readDiagnosticLogsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.DiagnosticLogsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAcceptedCommandListAttributeCallback(), + readDiagnosticLogsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo); + Map readDiagnosticLogsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readEventListAttribute( + (ChipClusters.DiagnosticLogsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterEventListAttributeCallback(), + readDiagnosticLogsEventListCommandParams + ); + result.put("readEventListAttribute", readDiagnosticLogsEventListAttributeInteractionInfo); + Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( + (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + Map readDiagnosticLogsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDiagnosticLogsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readDiagnosticLogsFeatureMapAttributeInteractionInfo); + Map readDiagnosticLogsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDiagnosticLogsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readDiagnosticLogsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readGeneralDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readGeneralDiagnosticsNetworkInterfacesCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readNetworkInterfacesAttribute( + (ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback(), + readGeneralDiagnosticsNetworkInterfacesCommandParams + ); + result.put("readNetworkInterfacesAttribute", readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo); + Map readGeneralDiagnosticsRebootCountCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsRebootCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readRebootCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsRebootCountCommandParams + ); + result.put("readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); + Map readGeneralDiagnosticsUpTimeCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readUpTimeAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralDiagnosticsUpTimeCommandParams + ); + result.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); + Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTotalOperationalHoursAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralDiagnosticsTotalOperationalHoursCommandParams + ); + result.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonCommandParams + ); + result.put("readBootReasonAttribute", readGeneralDiagnosticsBootReasonAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams + ); + result.put("readActiveHardwareFaultsAttribute", readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveRadioFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveRadioFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback(), + readGeneralDiagnosticsActiveRadioFaultsCommandParams + ); + result.put("readActiveRadioFaultsAttribute", readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveNetworkFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveNetworkFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback(), + readGeneralDiagnosticsActiveNetworkFaultsCommandParams + ); + result.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsTestEventTriggersEnabledCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTestEventTriggersEnabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readGeneralDiagnosticsTestEventTriggersEnabledCommandParams + ); + result.put("readTestEventTriggersEnabledAttribute", readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo); + Map readGeneralDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readGeneralDiagnosticsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readGeneralDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readGeneralDiagnosticsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readGeneralDiagnosticsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readEventListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterEventListAttributeCallback(), + readGeneralDiagnosticsEventListCommandParams + ); + result.put("readEventListAttribute", readGeneralDiagnosticsEventListAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralDiagnosticsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readGeneralDiagnosticsFeatureMapAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readSoftwareDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readSoftwareDiagnosticsThreadMetricsCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readThreadMetricsAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback(), + readSoftwareDiagnosticsThreadMetricsCommandParams + ); + result.put("readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); + Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapFreeAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsCurrentHeapFreeCommandParams + ); + result.put("readCurrentHeapFreeAttribute", readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); + Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapUsedAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsCurrentHeapUsedCommandParams + ); + result.put("readCurrentHeapUsedAttribute", readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); + Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapHighWatermarkAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams + ); + result.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readSoftwareDiagnosticsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readSoftwareDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readSoftwareDiagnosticsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readSoftwareDiagnosticsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readEventListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterEventListAttributeCallback(), + readSoftwareDiagnosticsEventListCommandParams + ); + result.put("readEventListAttribute", readSoftwareDiagnosticsEventListAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); + Map readSoftwareDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo); + Map readSoftwareDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSoftwareDiagnosticsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readThreadNetworkDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ChannelAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterChannelAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams + ); + result.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RoutingRoleAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams + ); + result.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.NetworkNameAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNetworkNameAttributeCallback(), + readThreadNetworkDiagnosticsNetworkNameCommandParams + ); + result.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.PanIdAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterPanIdAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams + ); + result.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ExtendedPanIdAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterExtendedPanIdAttributeCallback(), + readThreadNetworkDiagnosticsExtendedPanIdCommandParams + ); + result.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.MeshLocalPrefixAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterMeshLocalPrefixAttributeCallback(), + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams + ); + result.put("readMeshLocalPrefixAttribute", readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsOverrunCountCommandParams + ); + result.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableCommandParams + ); + result.put("readNeighborTableAttribute", readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableCommandParams + ); + result.put("readRouteTableAttribute", readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.PartitionIdAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterPartitionIdAttributeCallback(), + readThreadNetworkDiagnosticsPartitionIdCommandParams + ); + result.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.WeightingAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterWeightingAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams + ); + result.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.DataVersionAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterDataVersionAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams + ); + result.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.StableDataVersionAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterStableDataVersionAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams + ); + result.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.LeaderRouterIdAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterLeaderRouterIdAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams + ); + result.put("readLeaderRouterIdAttribute", readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDetachedRoleCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDetachedRoleCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDetachedRoleCountCommandParams + ); + result.put("readDetachedRoleCountAttribute", readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChildRoleCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChildRoleCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChildRoleCountCommandParams + ); + result.put("readChildRoleCountAttribute", readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouterRoleCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouterRoleCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRouterRoleCountCommandParams + ); + result.put("readRouterRoleCountAttribute", readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRoleCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRoleCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRoleCountCommandParams + ); + result.put("readLeaderRoleCountAttribute", readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttachAttemptCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttachAttemptCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsAttachAttemptCountCommandParams + ); + result.put("readAttachAttemptCountAttribute", readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdChangeCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams + ); + result.put("readPartitionIdChangeCountAttribute", readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readBetterPartitionAttachAttemptCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams + ); + result.put("readBetterPartitionAttachAttemptCountAttribute", readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsParentChangeCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readParentChangeCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsParentChangeCountCommandParams + ); + result.put("readParentChangeCountAttribute", readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxTotalCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxTotalCountCommandParams + ); + result.put("readTxTotalCountAttribute", readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxUnicastCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxUnicastCountCommandParams + ); + result.put("readTxUnicastCountAttribute", readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBroadcastCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams + ); + result.put("readTxBroadcastCountAttribute", readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckRequestedCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams + ); + result.put("readTxAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckedCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxAckedCountCommandParams + ); + result.put("readTxAckedCountAttribute", readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxNoAckRequestedCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams + ); + result.put("readTxNoAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDataCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDataCountCommandParams + ); + result.put("readTxDataCountAttribute", readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataPollCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDataPollCountCommandParams + ); + result.put("readTxDataPollCountAttribute", readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxBeaconCountCommandParams + ); + result.put("readTxBeaconCountAttribute", readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconRequestCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams + ); + result.put("readTxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxOtherCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxOtherCountCommandParams + ); + result.put("readTxOtherCountAttribute", readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxRetryCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxRetryCountCommandParams + ); + result.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams + ); + result.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams + ); + result.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams + ); + result.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams + ); + result.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams + ); + result.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxTotalCountCommandParams + ); + result.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxUnicastCountCommandParams + ); + result.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams + ); + result.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDataCountCommandParams + ); + result.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDataPollCountCommandParams + ); + result.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxBeaconCountCommandParams + ); + result.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams + ); + result.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxOtherCountCommandParams + ); + result.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams + ); + result.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams + ); + result.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams + ); + result.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams + ); + result.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams + ); + result.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams + ); + result.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrSecCountCommandParams + ); + result.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams + ); + result.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams + ); + result.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveTimestampAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveTimestampAttributeCallback(), + readThreadNetworkDiagnosticsActiveTimestampCommandParams + ); + result.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.PendingTimestampAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterPendingTimestampAttributeCallback(), + readThreadNetworkDiagnosticsPendingTimestampCommandParams + ); + result.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.DelayAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterDelayAttributeCallback(), + readThreadNetworkDiagnosticsDelayCommandParams + ); + result.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelPage0MaskCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelPage0MaskAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ChannelPage0MaskAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterChannelPage0MaskAttributeCallback(), + readThreadNetworkDiagnosticsChannelPage0MaskCommandParams + ); + result.put("readChannelPage0MaskAttribute", readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams + ); + result.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readThreadNetworkDiagnosticsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readThreadNetworkDiagnosticsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readEventListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterEventListAttributeCallback(), + readThreadNetworkDiagnosticsEventListCommandParams + ); + result.put("readEventListAttribute", readThreadNetworkDiagnosticsEventListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readWiFiNetworkDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.BssidAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterBssidAttributeCallback(), + readWiFiNetworkDiagnosticsBssidCommandParams + ); + result.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.SecurityTypeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams + ); + result.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.WiFiVersionAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterWiFiVersionAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams + ); + result.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.ChannelNumberAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterChannelNumberAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams + ); + result.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.RssiAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterRssiAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams + ); + result.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconLostCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterBeaconLostCountAttributeCallback(), + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams + ); + result.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconRxCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterBeaconRxCountAttributeCallback(), + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams + ); + result.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketMulticastRxCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastRxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams + ); + result.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketMulticastTxCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastTxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams + ); + result.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketUnicastRxCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastRxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams + ); + result.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketUnicastTxCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastTxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams + ); + result.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.CurrentMaxRateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterCurrentMaxRateAttributeCallback(), + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams + ); + result.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.OverrunCountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterOverrunCountAttributeCallback(), + readWiFiNetworkDiagnosticsOverrunCountCommandParams + ); + result.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readEventListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterEventListAttributeCallback(), + readWiFiNetworkDiagnosticsEventListCommandParams + ); + result.put("readEventListAttribute", readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWiFiNetworkDiagnosticsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readEthernetNetworkDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.PHYRateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterPHYRateAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams + ); + result.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.FullDuplexAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterFullDuplexAttributeCallback(), + readEthernetNetworkDiagnosticsFullDuplexCommandParams + ); + result.put("readFullDuplexAttribute", readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketRxCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsPacketRxCountCommandParams + ); + result.put("readPacketRxCountAttribute", readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketTxCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsPacketTxCountCommandParams + ); + result.put("readPacketTxCountAttribute", readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTxErrCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsTxErrCountCommandParams + ); + result.put("readTxErrCountAttribute", readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCollisionCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsCollisionCountCommandParams + ); + result.put("readCollisionCountAttribute", readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsOverrunCountCommandParams + ); + result.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.CarrierDetectAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterCarrierDetectAttributeCallback(), + readEthernetNetworkDiagnosticsCarrierDetectCommandParams + ); + result.put("readCarrierDetectAttribute", readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTimeSinceResetAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams + ); + result.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readEventListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterEventListAttributeCallback(), + readEthernetNetworkDiagnosticsEventListCommandParams + ); + result.put("readEventListAttribute", readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTimeSynchronizationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTimeSynchronizationUTCTimeCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationUTCTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readUTCTimeAttribute( + (ChipClusters.TimeSynchronizationCluster.UTCTimeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterUTCTimeAttributeCallback(), + readTimeSynchronizationUTCTimeCommandParams + ); + result.put("readUTCTimeAttribute", readTimeSynchronizationUTCTimeAttributeInteractionInfo); + Map readTimeSynchronizationGranularityCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationGranularityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readGranularityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationGranularityCommandParams + ); + result.put("readGranularityAttribute", readTimeSynchronizationGranularityAttributeInteractionInfo); + Map readTimeSynchronizationTimeSourceCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeSourceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeSourceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationTimeSourceCommandParams + ); + result.put("readTimeSourceAttribute", readTimeSynchronizationTimeSourceAttributeInteractionInfo); + Map readTimeSynchronizationDefaultNTPCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationDefaultNTPAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readDefaultNTPAttribute( + (ChipClusters.TimeSynchronizationCluster.DefaultNTPAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterDefaultNTPAttributeCallback(), + readTimeSynchronizationDefaultNTPCommandParams + ); + result.put("readDefaultNTPAttribute", readTimeSynchronizationDefaultNTPAttributeInteractionInfo); + Map readTimeSynchronizationTimeZoneCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeZoneAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeZoneAttribute( + (ChipClusters.TimeSynchronizationCluster.TimeZoneAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterTimeZoneAttributeCallback(), + readTimeSynchronizationTimeZoneCommandParams + ); + result.put("readTimeZoneAttribute", readTimeSynchronizationTimeZoneAttributeInteractionInfo); + Map readTimeSynchronizationDSTOffsetCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationDSTOffsetAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readDSTOffsetAttribute( + (ChipClusters.TimeSynchronizationCluster.DSTOffsetAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterDSTOffsetAttributeCallback(), + readTimeSynchronizationDSTOffsetCommandParams + ); + result.put("readDSTOffsetAttribute", readTimeSynchronizationDSTOffsetAttributeInteractionInfo); + Map readTimeSynchronizationLocalTimeCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationLocalTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readLocalTimeAttribute( + (ChipClusters.TimeSynchronizationCluster.LocalTimeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterLocalTimeAttributeCallback(), + readTimeSynchronizationLocalTimeCommandParams + ); + result.put("readLocalTimeAttribute", readTimeSynchronizationLocalTimeAttributeInteractionInfo); + Map readTimeSynchronizationTimeZoneDatabaseCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeZoneDatabaseAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationTimeZoneDatabaseCommandParams + ); + result.put("readTimeZoneDatabaseAttribute", readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo); + Map readTimeSynchronizationNTPServerAvailableCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readNTPServerAvailableAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readTimeSynchronizationNTPServerAvailableCommandParams + ); + result.put("readNTPServerAvailableAttribute", readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo); + Map readTimeSynchronizationTimeZoneListMaxSizeCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeZoneListMaxSizeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationTimeZoneListMaxSizeCommandParams + ); + result.put("readTimeZoneListMaxSizeAttribute", readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo); + Map readTimeSynchronizationDSTOffsetListMaxSizeCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readDSTOffsetListMaxSizeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationDSTOffsetListMaxSizeCommandParams + ); + result.put("readDSTOffsetListMaxSizeAttribute", readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo); + Map readTimeSynchronizationSupportsDNSResolveCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readSupportsDNSResolveAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readTimeSynchronizationSupportsDNSResolveCommandParams + ); + result.put("readSupportsDNSResolveAttribute", readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo); + Map readTimeSynchronizationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TimeSynchronizationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterGeneratedCommandListAttributeCallback(), + readTimeSynchronizationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo); + Map readTimeSynchronizationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TimeSynchronizationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterAcceptedCommandListAttributeCallback(), + readTimeSynchronizationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo); + Map readTimeSynchronizationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readEventListAttribute( + (ChipClusters.TimeSynchronizationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterEventListAttributeCallback(), + readTimeSynchronizationEventListCommandParams + ); + result.put("readEventListAttribute", readTimeSynchronizationEventListAttributeInteractionInfo); + Map readTimeSynchronizationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readAttributeListAttribute( + (ChipClusters.TimeSynchronizationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterAttributeListAttributeCallback(), + readTimeSynchronizationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTimeSynchronizationAttributeListAttributeInteractionInfo); + Map readTimeSynchronizationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTimeSynchronizationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTimeSynchronizationFeatureMapAttributeInteractionInfo); + Map readTimeSynchronizationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTimeSynchronizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTimeSynchronizationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBridgedDeviceBasicInformationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBridgedDeviceBasicInformationVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readVendorNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationVendorNameCommandParams + ); + result.put("readVendorNameAttribute", readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationVendorIDCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readVendorIDAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicInformationVendorIDCommandParams + ); + result.put("readVendorIDAttribute", readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationProductNameCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readProductNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationProductNameCommandParams + ); + result.put("readProductNameAttribute", readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationNodeLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readNodeLabelAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationNodeLabelCommandParams + ); + result.put("readNodeLabelAttribute", readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationHardwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readHardwareVersionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicInformationHardwareVersionCommandParams + ); + result.put("readHardwareVersionAttribute", readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationHardwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationHardwareVersionStringCommandParams + ); + result.put("readHardwareVersionStringAttribute", readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationSoftwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readSoftwareVersionAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBridgedDeviceBasicInformationSoftwareVersionCommandParams + ); + result.put("readSoftwareVersionAttribute", readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams + ); + result.put("readSoftwareVersionStringAttribute", readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationManufacturingDateCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationManufacturingDateCommandParams + ); + result.put("readManufacturingDateAttribute", readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationPartNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readPartNumberAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationPartNumberCommandParams + ); + result.put("readPartNumberAttribute", readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationProductURLCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readProductURLAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationProductURLCommandParams + ); + result.put("readProductURLAttribute", readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationProductLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readProductLabelAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationProductLabelCommandParams + ); + result.put("readProductLabelAttribute", readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationSerialNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readSerialNumberAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationSerialNumberCommandParams + ); + result.put("readSerialNumberAttribute", readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationReachableCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationReachableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readReachableAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBridgedDeviceBasicInformationReachableCommandParams + ); + result.put("readReachableAttribute", readBridgedDeviceBasicInformationReachableAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationUniqueIDCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readUniqueIDAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationUniqueIDCommandParams + ); + result.put("readUniqueIDAttribute", readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterGeneratedCommandListAttributeCallback(), + readBridgedDeviceBasicInformationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterAcceptedCommandListAttributeCallback(), + readBridgedDeviceBasicInformationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readEventListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterEventListAttributeCallback(), + readBridgedDeviceBasicInformationEventListCommandParams + ); + result.put("readEventListAttribute", readBridgedDeviceBasicInformationEventListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readAttributeListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicInformationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBridgedDeviceBasicInformationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicInformationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readSwitchInteractionInfo() { + Map result = new LinkedHashMap<>();Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams + ); + result.put("readNumberOfPositionsAttribute", readSwitchNumberOfPositionsAttributeInteractionInfo); + Map readSwitchCurrentPositionCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchCurrentPositionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readCurrentPositionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchCurrentPositionCommandParams + ); + result.put("readCurrentPositionAttribute", readSwitchCurrentPositionAttributeInteractionInfo); + Map readSwitchMultiPressMaxCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchMultiPressMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readMultiPressMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchMultiPressMaxCommandParams + ); + result.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.SwitchCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSwitchClusterGeneratedCommandListAttributeCallback(), + readSwitchGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readSwitchGeneratedCommandListAttributeInteractionInfo); + Map readSwitchAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.SwitchCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSwitchClusterAcceptedCommandListAttributeCallback(), + readSwitchAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readSwitchAcceptedCommandListAttributeInteractionInfo); + Map readSwitchEventListCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readEventListAttribute( + (ChipClusters.SwitchCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSwitchClusterEventListAttributeCallback(), + readSwitchEventListCommandParams + ); + result.put("readEventListAttribute", readSwitchEventListAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( + (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), + readSwitchAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); + Map readSwitchFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSwitchFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readSwitchFeatureMapAttributeInteractionInfo); + Map readSwitchClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readAdministratorCommissioningInteractionInfo() { + Map result = new LinkedHashMap<>();Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams + ); + result.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( + (ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAdminFabricIndexAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams + ); + result.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( + (ChipClusters.AdministratorCommissioningCluster.AdminVendorIdAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAdminVendorIdAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams + ); + result.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map readAdministratorCommissioningGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.AdministratorCommissioningCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterGeneratedCommandListAttributeCallback(), + readAdministratorCommissioningGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo); + Map readAdministratorCommissioningAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.AdministratorCommissioningCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAcceptedCommandListAttributeCallback(), + readAdministratorCommissioningAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo); + Map readAdministratorCommissioningEventListCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readEventListAttribute( + (ChipClusters.AdministratorCommissioningCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterEventListAttributeCallback(), + readAdministratorCommissioningEventListCommandParams + ); + result.put("readEventListAttribute", readAdministratorCommissioningEventListAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( + (ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAdministratorCommissioningFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readAdministratorCommissioningFeatureMapAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOperationalCredentialsInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOperationalCredentialsNOCsCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsNOCsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readNOCsAttribute( + (ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterNOCsAttributeCallback(), + readOperationalCredentialsNOCsCommandParams + ); + result.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsAttribute( + (ChipClusters.OperationalCredentialsCluster.FabricsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsAttributeCallback(), + readOperationalCredentialsFabricsCommandParams + ); + result.put("readFabricsAttribute", readOperationalCredentialsFabricsAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams + ); + result.put("readSupportedFabricsAttribute", readOperationalCredentialsSupportedFabricsAttributeInteractionInfo); + Map readOperationalCredentialsCommissionedFabricsCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readCommissionedFabricsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCommissionedFabricsCommandParams + ); + result.put("readCommissionedFabricsAttribute", readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo); + Map readOperationalCredentialsTrustedRootCertificatesCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readTrustedRootCertificatesAttribute( + (ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback(), + readOperationalCredentialsTrustedRootCertificatesCommandParams + ); + result.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams + ); + result.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OperationalCredentialsCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterGeneratedCommandListAttributeCallback(), + readOperationalCredentialsGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo); + Map readOperationalCredentialsAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OperationalCredentialsCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAcceptedCommandListAttributeCallback(), + readOperationalCredentialsAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo); + Map readOperationalCredentialsEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readEventListAttribute( + (ChipClusters.OperationalCredentialsCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterEventListAttributeCallback(), + readOperationalCredentialsEventListCommandParams + ); + result.put("readEventListAttribute", readOperationalCredentialsEventListAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( + (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOperationalCredentialsFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOperationalCredentialsFeatureMapAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readGroupKeyManagementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readGroupKeyManagementGroupKeyMapCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementGroupKeyMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readGroupKeyMapAttribute( + (ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback(), + readGroupKeyManagementGroupKeyMapCommandParams + ); + result.put("readGroupKeyMapAttribute", readGroupKeyManagementGroupKeyMapAttributeInteractionInfo); + Map readGroupKeyManagementGroupTableCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementGroupTableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readGroupTableAttribute( + (ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterGroupTableAttributeCallback(), + readGroupKeyManagementGroupTableCommandParams + ); + result.put("readGroupTableAttribute", readGroupKeyManagementGroupTableAttributeInteractionInfo); + Map readGroupKeyManagementMaxGroupsPerFabricCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readMaxGroupsPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementMaxGroupsPerFabricCommandParams + ); + result.put("readMaxGroupsPerFabricAttribute", readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementMaxGroupKeysPerFabricCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readMaxGroupKeysPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementMaxGroupKeysPerFabricCommandParams + ); + result.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.GroupKeyManagementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterGeneratedCommandListAttributeCallback(), + readGroupKeyManagementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo); + Map readGroupKeyManagementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.GroupKeyManagementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAcceptedCommandListAttributeCallback(), + readGroupKeyManagementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo); + Map readGroupKeyManagementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readEventListAttribute( + (ChipClusters.GroupKeyManagementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterEventListAttributeCallback(), + readGroupKeyManagementEventListCommandParams + ); + result.put("readEventListAttribute", readGroupKeyManagementEventListAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( + (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGroupKeyManagementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readGroupKeyManagementFeatureMapAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFixedLabelInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFixedLabelLabelListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readLabelListAttribute( + (ChipClusters.FixedLabelCluster.LabelListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterLabelListAttributeCallback(), + readFixedLabelLabelListCommandParams + ); + result.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FixedLabelCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterGeneratedCommandListAttributeCallback(), + readFixedLabelGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFixedLabelGeneratedCommandListAttributeInteractionInfo); + Map readFixedLabelAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FixedLabelCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAcceptedCommandListAttributeCallback(), + readFixedLabelAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFixedLabelAcceptedCommandListAttributeInteractionInfo); + Map readFixedLabelEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readEventListAttribute( + (ChipClusters.FixedLabelCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterEventListAttributeCallback(), + readFixedLabelEventListCommandParams + ); + result.put("readEventListAttribute", readFixedLabelEventListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( + (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), + readFixedLabelAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFixedLabelFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFixedLabelFeatureMapAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readUserLabelInteractionInfo() { + Map result = new LinkedHashMap<>();Map readUserLabelLabelListCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelLabelListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readLabelListAttribute( + (ChipClusters.UserLabelCluster.LabelListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterLabelListAttributeCallback(), + readUserLabelLabelListCommandParams + ); + result.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.UserLabelCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterGeneratedCommandListAttributeCallback(), + readUserLabelGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readUserLabelGeneratedCommandListAttributeInteractionInfo); + Map readUserLabelAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.UserLabelCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterAcceptedCommandListAttributeCallback(), + readUserLabelAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readUserLabelAcceptedCommandListAttributeInteractionInfo); + Map readUserLabelEventListCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readEventListAttribute( + (ChipClusters.UserLabelCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterEventListAttributeCallback(), + readUserLabelEventListCommandParams + ); + result.put("readEventListAttribute", readUserLabelEventListAttributeInteractionInfo); + Map readUserLabelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readAttributeListAttribute( + (ChipClusters.UserLabelCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterAttributeListAttributeCallback(), + readUserLabelAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readUserLabelAttributeListAttributeInteractionInfo); + Map readUserLabelFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUserLabelFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readUserLabelFeatureMapAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readProxyConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readProxyConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ProxyConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterGeneratedCommandListAttributeCallback(), + readProxyConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readProxyConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readProxyConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ProxyConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterAcceptedCommandListAttributeCallback(), + readProxyConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readProxyConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readProxyConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.ProxyConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterEventListAttributeCallback(), + readProxyConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readProxyConfigurationEventListAttributeInteractionInfo); + Map readProxyConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.ProxyConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterAttributeListAttributeCallback(), + readProxyConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readProxyConfigurationAttributeListAttributeInteractionInfo); + Map readProxyConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readProxyConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readProxyConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readProxyConfigurationFeatureMapAttributeInteractionInfo); + Map readProxyConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readProxyConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readProxyConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readProxyConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readProxyDiscoveryInteractionInfo() { + Map result = new LinkedHashMap<>();Map readProxyDiscoveryGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ProxyDiscoveryCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterGeneratedCommandListAttributeCallback(), + readProxyDiscoveryGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo); + Map readProxyDiscoveryAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ProxyDiscoveryCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterAcceptedCommandListAttributeCallback(), + readProxyDiscoveryAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo); + Map readProxyDiscoveryEventListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyDiscoveryEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster).readEventListAttribute( + (ChipClusters.ProxyDiscoveryCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterEventListAttributeCallback(), + readProxyDiscoveryEventListCommandParams + ); + result.put("readEventListAttribute", readProxyDiscoveryEventListAttributeInteractionInfo); + Map readProxyDiscoveryAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyDiscoveryAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster).readAttributeListAttribute( + (ChipClusters.ProxyDiscoveryCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterAttributeListAttributeCallback(), + readProxyDiscoveryAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readProxyDiscoveryAttributeListAttributeInteractionInfo); + Map readProxyDiscoveryFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readProxyDiscoveryFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readProxyDiscoveryFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readProxyDiscoveryFeatureMapAttributeInteractionInfo); + Map readProxyDiscoveryClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readProxyDiscoveryClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readProxyDiscoveryClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readProxyDiscoveryClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readProxyValidInteractionInfo() { + Map result = new LinkedHashMap<>();Map readProxyValidGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyValidGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ProxyValidCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyValidClusterGeneratedCommandListAttributeCallback(), + readProxyValidGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readProxyValidGeneratedCommandListAttributeInteractionInfo); + Map readProxyValidAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyValidAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ProxyValidCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyValidClusterAcceptedCommandListAttributeCallback(), + readProxyValidAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readProxyValidAcceptedCommandListAttributeInteractionInfo); + Map readProxyValidEventListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyValidEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster).readEventListAttribute( + (ChipClusters.ProxyValidCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyValidClusterEventListAttributeCallback(), + readProxyValidEventListCommandParams + ); + result.put("readEventListAttribute", readProxyValidEventListAttributeInteractionInfo); + Map readProxyValidAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readProxyValidAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster).readAttributeListAttribute( + (ChipClusters.ProxyValidCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedProxyValidClusterAttributeListAttributeCallback(), + readProxyValidAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readProxyValidAttributeListAttributeInteractionInfo); + Map readProxyValidFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readProxyValidFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readProxyValidFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readProxyValidFeatureMapAttributeInteractionInfo); + Map readProxyValidClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readProxyValidClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readProxyValidClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readProxyValidClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBooleanStateInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBooleanStateStateValueCommandParams + ); + result.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BooleanStateCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterGeneratedCommandListAttributeCallback(), + readBooleanStateGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBooleanStateGeneratedCommandListAttributeInteractionInfo); + Map readBooleanStateAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BooleanStateCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAcceptedCommandListAttributeCallback(), + readBooleanStateAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBooleanStateAcceptedCommandListAttributeInteractionInfo); + Map readBooleanStateEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readEventListAttribute( + (ChipClusters.BooleanStateCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterEventListAttributeCallback(), + readBooleanStateEventListCommandParams + ); + result.put("readEventListAttribute", readBooleanStateEventListAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( + (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBooleanStateFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBooleanStateFeatureMapAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readIcdManagementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readIcdManagementIdleModeIntervalCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementIdleModeIntervalAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readIdleModeIntervalAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementIdleModeIntervalCommandParams + ); + result.put("readIdleModeIntervalAttribute", readIcdManagementIdleModeIntervalAttributeInteractionInfo); + Map readIcdManagementActiveModeIntervalCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementActiveModeIntervalAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readActiveModeIntervalAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementActiveModeIntervalCommandParams + ); + result.put("readActiveModeIntervalAttribute", readIcdManagementActiveModeIntervalAttributeInteractionInfo); + Map readIcdManagementActiveModeThresholdCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementActiveModeThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readActiveModeThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIcdManagementActiveModeThresholdCommandParams + ); + result.put("readActiveModeThresholdAttribute", readIcdManagementActiveModeThresholdAttributeInteractionInfo); + Map readIcdManagementRegisteredClientsCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementRegisteredClientsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readRegisteredClientsAttribute( + (ChipClusters.IcdManagementCluster.RegisteredClientsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIcdManagementClusterRegisteredClientsAttributeCallback(), + readIcdManagementRegisteredClientsCommandParams + ); + result.put("readRegisteredClientsAttribute", readIcdManagementRegisteredClientsAttributeInteractionInfo); + Map readIcdManagementICDCounterCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementICDCounterAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readICDCounterAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementICDCounterCommandParams + ); + result.put("readICDCounterAttribute", readIcdManagementICDCounterAttributeInteractionInfo); + Map readIcdManagementClientsSupportedPerFabricCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readClientsSupportedPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIcdManagementClientsSupportedPerFabricCommandParams + ); + result.put("readClientsSupportedPerFabricAttribute", readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo); + Map readIcdManagementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.IcdManagementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIcdManagementClusterGeneratedCommandListAttributeCallback(), + readIcdManagementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readIcdManagementGeneratedCommandListAttributeInteractionInfo); + Map readIcdManagementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.IcdManagementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIcdManagementClusterAcceptedCommandListAttributeCallback(), + readIcdManagementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readIcdManagementAcceptedCommandListAttributeInteractionInfo); + Map readIcdManagementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readEventListAttribute( + (ChipClusters.IcdManagementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIcdManagementClusterEventListAttributeCallback(), + readIcdManagementEventListCommandParams + ); + result.put("readEventListAttribute", readIcdManagementEventListAttributeInteractionInfo); + Map readIcdManagementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readAttributeListAttribute( + (ChipClusters.IcdManagementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIcdManagementClusterAttributeListAttributeCallback(), + readIcdManagementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readIcdManagementAttributeListAttributeInteractionInfo); + Map readIcdManagementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readIcdManagementFeatureMapAttributeInteractionInfo); + Map readIcdManagementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIcdManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIcdManagementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readIcdManagementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readModeSelectInteractionInfo() { + Map result = new LinkedHashMap<>();Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readModeSelectDescriptionCommandParams + ); + result.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectStandardNamespaceCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectStandardNamespaceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readStandardNamespaceAttribute( + (ChipClusters.ModeSelectCluster.StandardNamespaceAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterStandardNamespaceAttributeCallback(), + readModeSelectStandardNamespaceCommandParams + ); + result.put("readStandardNamespaceAttribute", readModeSelectStandardNamespaceAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( + (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams + ); + result.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams + ); + result.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( + (ChipClusters.ModeSelectCluster.StartUpModeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterStartUpModeAttributeCallback(), + readModeSelectStartUpModeCommandParams + ); + result.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( + (ChipClusters.ModeSelectCluster.OnModeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterOnModeAttributeCallback(), + readModeSelectOnModeCommandParams + ); + result.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ModeSelectCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterGeneratedCommandListAttributeCallback(), + readModeSelectGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readModeSelectGeneratedCommandListAttributeInteractionInfo); + Map readModeSelectAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ModeSelectCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterAcceptedCommandListAttributeCallback(), + readModeSelectAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readModeSelectAcceptedCommandListAttributeInteractionInfo); + Map readModeSelectEventListCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readEventListAttribute( + (ChipClusters.ModeSelectCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterEventListAttributeCallback(), + readModeSelectEventListCommandParams + ); + result.put("readEventListAttribute", readModeSelectEventListAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( + (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), + readModeSelectAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readModeSelectFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readModeSelectFeatureMapAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTemperatureControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTemperatureControlTemperatureSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlTemperatureSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readTemperatureSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlTemperatureSetpointCommandParams + ); + result.put("readTemperatureSetpointAttribute", readTemperatureControlTemperatureSetpointAttributeInteractionInfo); + Map readTemperatureControlMinTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlMinTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readMinTemperatureAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlMinTemperatureCommandParams + ); + result.put("readMinTemperatureAttribute", readTemperatureControlMinTemperatureAttributeInteractionInfo); + Map readTemperatureControlMaxTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlMaxTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readMaxTemperatureAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlMaxTemperatureCommandParams + ); + result.put("readMaxTemperatureAttribute", readTemperatureControlMaxTemperatureAttributeInteractionInfo); + Map readTemperatureControlStepCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlStepAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readStepAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlStepCommandParams + ); + result.put("readStepAttribute", readTemperatureControlStepAttributeInteractionInfo); + Map readTemperatureControlCurrentTemperatureLevelIndexCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readCurrentTemperatureLevelIndexAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlCurrentTemperatureLevelIndexCommandParams + ); + result.put("readCurrentTemperatureLevelIndexAttribute", readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo); + Map readTemperatureControlSupportedTemperatureLevelsCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readSupportedTemperatureLevelsAttribute( + (ChipClusters.TemperatureControlCluster.SupportedTemperatureLevelsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterSupportedTemperatureLevelsAttributeCallback(), + readTemperatureControlSupportedTemperatureLevelsCommandParams + ); + result.put("readSupportedTemperatureLevelsAttribute", readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo); + Map readTemperatureControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TemperatureControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterGeneratedCommandListAttributeCallback(), + readTemperatureControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTemperatureControlGeneratedCommandListAttributeInteractionInfo); + Map readTemperatureControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TemperatureControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterAcceptedCommandListAttributeCallback(), + readTemperatureControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTemperatureControlAcceptedCommandListAttributeInteractionInfo); + Map readTemperatureControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readEventListAttribute( + (ChipClusters.TemperatureControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterEventListAttributeCallback(), + readTemperatureControlEventListCommandParams + ); + result.put("readEventListAttribute", readTemperatureControlEventListAttributeInteractionInfo); + Map readTemperatureControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.TemperatureControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterAttributeListAttributeCallback(), + readTemperatureControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTemperatureControlAttributeListAttributeInteractionInfo); + Map readTemperatureControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTemperatureControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTemperatureControlFeatureMapAttributeInteractionInfo); + Map readTemperatureControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTemperatureControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readRefrigeratorAlarmInteractionInfo() { + Map result = new LinkedHashMap<>();Map readRefrigeratorAlarmMaskCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readMaskAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmMaskCommandParams + ); + result.put("readMaskAttribute", readRefrigeratorAlarmMaskAttributeInteractionInfo); + Map readRefrigeratorAlarmLatchCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmLatchAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readLatchAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmLatchCommandParams + ); + result.put("readLatchAttribute", readRefrigeratorAlarmLatchAttributeInteractionInfo); + Map readRefrigeratorAlarmStateCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readStateAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmStateCommandParams + ); + result.put("readStateAttribute", readRefrigeratorAlarmStateAttributeInteractionInfo); + Map readRefrigeratorAlarmGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterGeneratedCommandListAttributeCallback(), + readRefrigeratorAlarmGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo); + Map readRefrigeratorAlarmAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterAcceptedCommandListAttributeCallback(), + readRefrigeratorAlarmAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo); + Map readRefrigeratorAlarmEventListCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readEventListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterEventListAttributeCallback(), + readRefrigeratorAlarmEventListCommandParams + ); + result.put("readEventListAttribute", readRefrigeratorAlarmEventListAttributeInteractionInfo); + Map readRefrigeratorAlarmAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readAttributeListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterAttributeListAttributeCallback(), + readRefrigeratorAlarmAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readRefrigeratorAlarmAttributeListAttributeInteractionInfo); + Map readRefrigeratorAlarmFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readRefrigeratorAlarmFeatureMapAttributeInteractionInfo); + Map readRefrigeratorAlarmClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRefrigeratorAlarmClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readAirQualityInteractionInfo() { + Map result = new LinkedHashMap<>();Map readAirQualityAirQualityCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityAirQualityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readAirQualityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAirQualityAirQualityCommandParams + ); + result.put("readAirQualityAttribute", readAirQualityAirQualityAttributeInteractionInfo); + Map readAirQualityGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.AirQualityCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAirQualityClusterGeneratedCommandListAttributeCallback(), + readAirQualityGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readAirQualityGeneratedCommandListAttributeInteractionInfo); + Map readAirQualityAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.AirQualityCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAirQualityClusterAcceptedCommandListAttributeCallback(), + readAirQualityAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readAirQualityAcceptedCommandListAttributeInteractionInfo); + Map readAirQualityEventListCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readEventListAttribute( + (ChipClusters.AirQualityCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAirQualityClusterEventListAttributeCallback(), + readAirQualityEventListCommandParams + ); + result.put("readEventListAttribute", readAirQualityEventListAttributeInteractionInfo); + Map readAirQualityAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readAttributeListAttribute( + (ChipClusters.AirQualityCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAirQualityClusterAttributeListAttributeCallback(), + readAirQualityAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readAirQualityAttributeListAttributeInteractionInfo); + Map readAirQualityFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAirQualityFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readAirQualityFeatureMapAttributeInteractionInfo); + Map readAirQualityClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAirQualityClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAirQualityClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readAirQualityClusterRevisionAttributeInteractionInfo); + + 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 readDishwasherAlarmInteractionInfo() { + Map result = new LinkedHashMap<>();Map readDishwasherAlarmMaskCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readMaskAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmMaskCommandParams + ); + result.put("readMaskAttribute", readDishwasherAlarmMaskAttributeInteractionInfo); + Map readDishwasherAlarmLatchCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmLatchAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readLatchAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmLatchCommandParams + ); + result.put("readLatchAttribute", readDishwasherAlarmLatchAttributeInteractionInfo); + Map readDishwasherAlarmStateCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readStateAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmStateCommandParams + ); + result.put("readStateAttribute", readDishwasherAlarmStateAttributeInteractionInfo); + Map readDishwasherAlarmGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.DishwasherAlarmCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterGeneratedCommandListAttributeCallback(), + readDishwasherAlarmGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo); + Map readDishwasherAlarmAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.DishwasherAlarmCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterAcceptedCommandListAttributeCallback(), + readDishwasherAlarmAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo); + Map readDishwasherAlarmEventListCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readEventListAttribute( + (ChipClusters.DishwasherAlarmCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterEventListAttributeCallback(), + readDishwasherAlarmEventListCommandParams + ); + result.put("readEventListAttribute", readDishwasherAlarmEventListAttributeInteractionInfo); + Map readDishwasherAlarmAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readAttributeListAttribute( + (ChipClusters.DishwasherAlarmCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterAttributeListAttributeCallback(), + readDishwasherAlarmAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readDishwasherAlarmAttributeListAttributeInteractionInfo); + Map readDishwasherAlarmFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readDishwasherAlarmFeatureMapAttributeInteractionInfo); + Map readDishwasherAlarmClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDishwasherAlarmClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readDishwasherAlarmClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readHepaFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readHepaFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readHepaFilterMonitoringConditionAttributeInteractionInfo); + Map readHepaFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readHepaFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readHepaFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readHepaFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readHepaFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.HepaFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readHepaFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readHepaFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.HepaFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readHepaFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readHepaFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.HepaFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterEventListAttributeCallback(), + readHepaFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readHepaFilterMonitoringEventListAttributeInteractionInfo); + Map readHepaFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.HepaFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterAttributeListAttributeCallback(), + readHepaFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readHepaFilterMonitoringAttributeListAttributeInteractionInfo); + Map readHepaFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHepaFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readHepaFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readHepaFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readActivatedCarbonFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readActivatedCarbonFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterEventListAttributeCallback(), + readActivatedCarbonFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterAttributeListAttributeCallback(), + readActivatedCarbonFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readActivatedCarbonFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readCeramicFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readCeramicFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readCeramicFilterMonitoringConditionAttributeInteractionInfo); + Map readCeramicFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readCeramicFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readCeramicFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readCeramicFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readCeramicFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readCeramicFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readCeramicFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readCeramicFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readCeramicFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterEventListAttributeCallback(), + readCeramicFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readCeramicFilterMonitoringEventListAttributeInteractionInfo); + Map readCeramicFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterAttributeListAttributeCallback(), + readCeramicFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readCeramicFilterMonitoringAttributeListAttributeInteractionInfo); + Map readCeramicFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCeramicFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readCeramicFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readElectrostaticFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readElectrostaticFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readElectrostaticFilterMonitoringConditionAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readElectrostaticFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readElectrostaticFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterEventListAttributeCallback(), + readElectrostaticFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readElectrostaticFilterMonitoringEventListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterAttributeListAttributeCallback(), + readElectrostaticFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectrostaticFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readUvFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readUvFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readUvFilterMonitoringConditionAttributeInteractionInfo); + Map readUvFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readUvFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readUvFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readUvFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUvFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readUvFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.UvFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readUvFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readUvFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.UvFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readUvFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readUvFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.UvFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterEventListAttributeCallback(), + readUvFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readUvFilterMonitoringEventListAttributeInteractionInfo); + Map readUvFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.UvFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterAttributeListAttributeCallback(), + readUvFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readUvFilterMonitoringAttributeListAttributeInteractionInfo); + Map readUvFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUvFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readUvFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readUvFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readUvFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readIonizingFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readIonizingFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readIonizingFilterMonitoringConditionAttributeInteractionInfo); + Map readIonizingFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readIonizingFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readIonizingFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readIonizingFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readIonizingFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readIonizingFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readIonizingFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readIonizingFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readIonizingFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterEventListAttributeCallback(), + readIonizingFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readIonizingFilterMonitoringEventListAttributeInteractionInfo); + Map readIonizingFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterAttributeListAttributeCallback(), + readIonizingFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readIonizingFilterMonitoringAttributeListAttributeInteractionInfo); + Map readIonizingFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIonizingFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readIonizingFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readZeoliteFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readZeoliteFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readZeoliteFilterMonitoringConditionAttributeInteractionInfo); + Map readZeoliteFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readZeoliteFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readZeoliteFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readZeoliteFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readZeoliteFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readZeoliteFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readZeoliteFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterEventListAttributeCallback(), + readZeoliteFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readZeoliteFilterMonitoringEventListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterAttributeListAttributeCallback(), + readZeoliteFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readZeoliteFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readZeoliteFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOzoneFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOzoneFilterMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readOzoneFilterMonitoringConditionAttributeInteractionInfo); + Map readOzoneFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readOzoneFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readOzoneFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOzoneFilterMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readOzoneFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readOzoneFilterMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readOzoneFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readOzoneFilterMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readOzoneFilterMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterEventListAttributeCallback(), + readOzoneFilterMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readOzoneFilterMonitoringEventListAttributeInteractionInfo); + Map readOzoneFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterAttributeListAttributeCallback(), + readOzoneFilterMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOzoneFilterMonitoringAttributeListAttributeInteractionInfo); + Map readOzoneFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOzoneFilterMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readOzoneFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readWaterTankMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readWaterTankMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readWaterTankMonitoringConditionAttributeInteractionInfo); + Map readWaterTankMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo); + Map readWaterTankMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readWaterTankMonitoringChangeIndicationAttributeInteractionInfo); + Map readWaterTankMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readWaterTankMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readWaterTankMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.WaterTankMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterGeneratedCommandListAttributeCallback(), + readWaterTankMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readWaterTankMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.WaterTankMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterAcceptedCommandListAttributeCallback(), + readWaterTankMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readWaterTankMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.WaterTankMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterEventListAttributeCallback(), + readWaterTankMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readWaterTankMonitoringEventListAttributeInteractionInfo); + Map readWaterTankMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.WaterTankMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterAttributeListAttributeCallback(), + readWaterTankMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readWaterTankMonitoringAttributeListAttributeInteractionInfo); + Map readWaterTankMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWaterTankMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readWaterTankMonitoringFeatureMapAttributeInteractionInfo); + Map readWaterTankMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readWaterTankMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFuelTankMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFuelTankMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readFuelTankMonitoringConditionAttributeInteractionInfo); + Map readFuelTankMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo); + Map readFuelTankMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readFuelTankMonitoringChangeIndicationAttributeInteractionInfo); + Map readFuelTankMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readFuelTankMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readFuelTankMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FuelTankMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterGeneratedCommandListAttributeCallback(), + readFuelTankMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readFuelTankMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FuelTankMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterAcceptedCommandListAttributeCallback(), + readFuelTankMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readFuelTankMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.FuelTankMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterEventListAttributeCallback(), + readFuelTankMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readFuelTankMonitoringEventListAttributeInteractionInfo); + Map readFuelTankMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.FuelTankMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterAttributeListAttributeCallback(), + readFuelTankMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFuelTankMonitoringAttributeListAttributeInteractionInfo); + Map readFuelTankMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFuelTankMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFuelTankMonitoringFeatureMapAttributeInteractionInfo); + Map readFuelTankMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFuelTankMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readInkCartridgeMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readInkCartridgeMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readInkCartridgeMonitoringConditionAttributeInteractionInfo); + Map readInkCartridgeMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); + Map readInkCartridgeMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo); + Map readInkCartridgeMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readInkCartridgeMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readInkCartridgeMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), + readInkCartridgeMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readInkCartridgeMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), + readInkCartridgeMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readInkCartridgeMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterEventListAttributeCallback(), + readInkCartridgeMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readInkCartridgeMonitoringEventListAttributeInteractionInfo); + Map readInkCartridgeMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterAttributeListAttributeCallback(), + readInkCartridgeMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readInkCartridgeMonitoringAttributeListAttributeInteractionInfo); + Map readInkCartridgeMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readInkCartridgeMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo); + Map readInkCartridgeMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTonerCartridgeMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTonerCartridgeMonitoringConditionCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringConditionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readConditionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringConditionCommandParams + ); + result.put("readConditionAttribute", readTonerCartridgeMonitoringConditionAttributeInteractionInfo); + Map readTonerCartridgeMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringDegradationDirectionCommandParams + ); + result.put("readDegradationDirectionAttribute", readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); + Map readTonerCartridgeMonitoringChangeIndicationCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readChangeIndicationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringChangeIndicationCommandParams + ); + result.put("readChangeIndicationAttribute", readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo); + Map readTonerCartridgeMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readInPlaceIndicatorAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readTonerCartridgeMonitoringInPlaceIndicatorCommandParams + ); + result.put("readInPlaceIndicatorAttribute", readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readTonerCartridgeMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), + readTonerCartridgeMonitoringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), + readTonerCartridgeMonitoringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readEventListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterEventListAttributeCallback(), + readTonerCartridgeMonitoringEventListCommandParams + ); + result.put("readEventListAttribute", readTonerCartridgeMonitoringEventListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readAttributeListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterAttributeListAttributeCallback(), + readTonerCartridgeMonitoringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTonerCartridgeMonitoringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo); + Map readTonerCartridgeMonitoringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readDoorLockInteractionInfo() { + Map result = new LinkedHashMap<>();Map readDoorLockLockStateCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( + (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterLockStateAttributeCallback(), + readDoorLockLockStateCommandParams + ); + result.put("readLockStateAttribute", readDoorLockLockStateAttributeInteractionInfo); + Map readDoorLockLockTypeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLockTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLockTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockTypeCommandParams + ); + result.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); + Map readDoorLockActuatorEnabledCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readActuatorEnabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockActuatorEnabledCommandParams + ); + result.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( + (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterDoorStateAttributeCallback(), + readDoorLockDoorStateCommandParams + ); + result.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockDoorOpenEventsCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockDoorOpenEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readDoorOpenEventsAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockDoorOpenEventsCommandParams + ); + result.put("readDoorOpenEventsAttribute", readDoorLockDoorOpenEventsAttributeInteractionInfo); + Map readDoorLockDoorClosedEventsCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockDoorClosedEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readDoorClosedEventsAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockDoorClosedEventsCommandParams + ); + result.put("readDoorClosedEventsAttribute", readDoorLockDoorClosedEventsAttributeInteractionInfo); + Map readDoorLockOpenPeriodCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockOpenPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readOpenPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockOpenPeriodCommandParams + ); + result.put("readOpenPeriodAttribute", readDoorLockOpenPeriodAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams + ); + result.put("readNumberOfTotalUsersSupportedAttribute", readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo); + Map readDoorLockNumberOfPINUsersSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfPINUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfPINUsersSupportedCommandParams + ); + result.put("readNumberOfPINUsersSupportedAttribute", readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo); + Map readDoorLockNumberOfRFIDUsersSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfRFIDUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfRFIDUsersSupportedCommandParams + ); + result.put("readNumberOfRFIDUsersSupportedAttribute", readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo); + Map readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfWeekDaySchedulesSupportedPerUserAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams + ); + result.put("readNumberOfWeekDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfYearDaySchedulesSupportedPerUserAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams + ); + result.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockNumberOfHolidaySchedulesSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfHolidaySchedulesSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfHolidaySchedulesSupportedCommandParams + ); + result.put("readNumberOfHolidaySchedulesSupportedAttribute", readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams + ); + result.put("readMaxPINCodeLengthAttribute", readDoorLockMaxPINCodeLengthAttributeInteractionInfo); + Map readDoorLockMinPINCodeLengthCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockMinPINCodeLengthAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readMinPINCodeLengthAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMinPINCodeLengthCommandParams + ); + result.put("readMinPINCodeLengthAttribute", readDoorLockMinPINCodeLengthAttributeInteractionInfo); + Map readDoorLockMaxRFIDCodeLengthCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readMaxRFIDCodeLengthAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxRFIDCodeLengthCommandParams + ); + result.put("readMaxRFIDCodeLengthAttribute", readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockMinRFIDCodeLengthCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockMinRFIDCodeLengthAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readMinRFIDCodeLengthAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMinRFIDCodeLengthCommandParams + ); + result.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockCredentialRulesSupportCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockCredentialRulesSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readCredentialRulesSupportAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockCredentialRulesSupportCommandParams + ); + result.put("readCredentialRulesSupportAttribute", readDoorLockCredentialRulesSupportAttributeInteractionInfo); + Map readDoorLockNumberOfCredentialsSupportedPerUserCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfCredentialsSupportedPerUserAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfCredentialsSupportedPerUserCommandParams + ); + result.put("readNumberOfCredentialsSupportedPerUserAttribute", readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readDoorLockLanguageCommandParams + ); + result.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockLEDSettingsCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLEDSettingsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLEDSettingsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLEDSettingsCommandParams + ); + result.put("readLEDSettingsAttribute", readDoorLockLEDSettingsAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockAutoRelockTimeCommandParams + ); + result.put("readAutoRelockTimeAttribute", readDoorLockAutoRelockTimeAttributeInteractionInfo); + Map readDoorLockSoundVolumeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockSoundVolumeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readSoundVolumeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockSoundVolumeCommandParams + ); + result.put("readSoundVolumeAttribute", readDoorLockSoundVolumeAttributeInteractionInfo); + Map readDoorLockOperatingModeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockOperatingModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readOperatingModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockOperatingModeCommandParams + ); + result.put("readOperatingModeAttribute", readDoorLockOperatingModeAttributeInteractionInfo); + Map readDoorLockSupportedOperatingModesCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockSupportedOperatingModesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readSupportedOperatingModesAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockSupportedOperatingModesCommandParams + ); + result.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockDefaultConfigurationRegisterCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readDefaultConfigurationRegisterAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDefaultConfigurationRegisterCommandParams + ); + result.put("readDefaultConfigurationRegisterAttribute", readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo); + Map readDoorLockEnableLocalProgrammingCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnableLocalProgrammingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnableLocalProgrammingAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnableLocalProgrammingCommandParams + ); + result.put("readEnableLocalProgrammingAttribute", readDoorLockEnableLocalProgrammingAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnableOneTouchLockingCommandParams + ); + result.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnableInsideStatusLEDCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnableInsideStatusLEDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnableInsideStatusLEDAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnableInsideStatusLEDCommandParams + ); + result.put("readEnableInsideStatusLEDAttribute", readDoorLockEnableInsideStatusLEDAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnablePrivacyModeButtonCommandParams + ); + result.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockLocalProgrammingFeaturesCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLocalProgrammingFeaturesAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLocalProgrammingFeaturesCommandParams + ); + result.put("readLocalProgrammingFeaturesAttribute", readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams + ); + result.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockUserCodeTemporaryDisableTimeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readUserCodeTemporaryDisableTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockUserCodeTemporaryDisableTimeCommandParams + ); + result.put("readUserCodeTemporaryDisableTimeAttribute", readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); + Map readDoorLockSendPINOverTheAirCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockSendPINOverTheAirAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readSendPINOverTheAirAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockSendPINOverTheAirCommandParams + ); + result.put("readSendPINOverTheAirAttribute", readDoorLockSendPINOverTheAirAttributeInteractionInfo); + Map readDoorLockRequirePINforRemoteOperationCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readRequirePINforRemoteOperationAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockRequirePINforRemoteOperationCommandParams + ); + result.put("readRequirePINforRemoteOperationAttribute", readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); + Map readDoorLockExpiringUserTimeoutCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockExpiringUserTimeoutAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readExpiringUserTimeoutAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockExpiringUserTimeoutCommandParams + ); + result.put("readExpiringUserTimeoutAttribute", readDoorLockExpiringUserTimeoutAttributeInteractionInfo); + Map readDoorLockGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.DoorLockCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterGeneratedCommandListAttributeCallback(), + readDoorLockGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readDoorLockGeneratedCommandListAttributeInteractionInfo); + Map readDoorLockAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.DoorLockCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterAcceptedCommandListAttributeCallback(), + readDoorLockAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readDoorLockAcceptedCommandListAttributeInteractionInfo); + Map readDoorLockEventListCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEventListAttribute( + (ChipClusters.DoorLockCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterEventListAttributeCallback(), + readDoorLockEventListCommandParams + ); + result.put("readEventListAttribute", readDoorLockEventListAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( + (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), + readDoorLockAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readDoorLockFeatureMapAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readWindowCoveringInteractionInfo() { + Map result = new LinkedHashMap<>();Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams + ); + result.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringPhysicalClosedLimitLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readPhysicalClosedLimitLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringPhysicalClosedLimitLiftCommandParams + ); + result.put("readPhysicalClosedLimitLiftAttribute", readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo); + Map readWindowCoveringPhysicalClosedLimitTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readPhysicalClosedLimitTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringPhysicalClosedLimitTiltCommandParams + ); + result.put("readPhysicalClosedLimitTiltAttribute", readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionLiftAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams + ); + result.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionTiltAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams + ); + result.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringNumberOfActuationsLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readNumberOfActuationsLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringNumberOfActuationsLiftCommandParams + ); + result.put("readNumberOfActuationsLiftAttribute", readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo); + Map readWindowCoveringNumberOfActuationsTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readNumberOfActuationsTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringNumberOfActuationsTiltCommandParams + ); + result.put("readNumberOfActuationsTiltAttribute", readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams + ); + result.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionLiftPercentageAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams + ); + result.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionTiltPercentageAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams + ); + result.put("readCurrentPositionTiltPercentageAttribute", readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo); + Map readWindowCoveringOperationalStatusCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringOperationalStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readOperationalStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringOperationalStatusCommandParams + ); + result.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterTargetPositionLiftPercent100thsAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams + ); + result.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterTargetPositionTiltPercent100thsAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams + ); + result.put("readTargetPositionTiltPercent100thsAttribute", readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo); + Map readWindowCoveringEndProductTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringEndProductTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readEndProductTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringEndProductTypeCommandParams + ); + result.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionLiftPercent100thsAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams + ); + result.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionTiltPercent100thsAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams + ); + result.put("readCurrentPositionTiltPercent100thsAttribute", readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo); + Map readWindowCoveringInstalledOpenLimitLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readInstalledOpenLimitLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledOpenLimitLiftCommandParams + ); + result.put("readInstalledOpenLimitLiftAttribute", readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo); + Map readWindowCoveringInstalledClosedLimitLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readInstalledClosedLimitLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledClosedLimitLiftCommandParams + ); + result.put("readInstalledClosedLimitLiftAttribute", readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo); + Map readWindowCoveringInstalledOpenLimitTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readInstalledOpenLimitTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledOpenLimitTiltCommandParams + ); + result.put("readInstalledOpenLimitTiltAttribute", readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo); + Map readWindowCoveringInstalledClosedLimitTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readInstalledClosedLimitTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledClosedLimitTiltCommandParams + ); + result.put("readInstalledClosedLimitTiltAttribute", readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo); + Map readWindowCoveringModeCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringModeCommandParams + ); + result.put("readModeAttribute", readWindowCoveringModeAttributeInteractionInfo); + Map readWindowCoveringSafetyStatusCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringSafetyStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readSafetyStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringSafetyStatusCommandParams + ); + result.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.WindowCoveringCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterGeneratedCommandListAttributeCallback(), + readWindowCoveringGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readWindowCoveringGeneratedCommandListAttributeInteractionInfo); + Map readWindowCoveringAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.WindowCoveringCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAcceptedCommandListAttributeCallback(), + readWindowCoveringAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readWindowCoveringAcceptedCommandListAttributeInteractionInfo); + Map readWindowCoveringEventListCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readEventListAttribute( + (ChipClusters.WindowCoveringCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterEventListAttributeCallback(), + readWindowCoveringEventListCommandParams + ); + result.put("readEventListAttribute", readWindowCoveringEventListAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( + (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); + Map readWindowCoveringFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWindowCoveringFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readWindowCoveringFeatureMapAttributeInteractionInfo); + Map readWindowCoveringClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBarrierControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams + ); + result.put("readBarrierMovingStateAttribute", readBarrierControlBarrierMovingStateAttributeInteractionInfo); + Map readBarrierControlBarrierSafetyStatusCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierSafetyStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierSafetyStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierSafetyStatusCommandParams + ); + result.put("readBarrierSafetyStatusAttribute", readBarrierControlBarrierSafetyStatusAttributeInteractionInfo); + Map readBarrierControlBarrierCapabilitiesCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCapabilitiesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierCapabilitiesAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCapabilitiesCommandParams + ); + result.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierOpenEventsCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierOpenEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierOpenEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierOpenEventsCommandParams + ); + result.put("readBarrierOpenEventsAttribute", readBarrierControlBarrierOpenEventsAttributeInteractionInfo); + Map readBarrierControlBarrierCloseEventsCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCloseEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierCloseEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCloseEventsCommandParams + ); + result.put("readBarrierCloseEventsAttribute", readBarrierControlBarrierCloseEventsAttributeInteractionInfo); + Map readBarrierControlBarrierCommandOpenEventsCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierCommandOpenEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCommandOpenEventsCommandParams + ); + result.put("readBarrierCommandOpenEventsAttribute", readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); + Map readBarrierControlBarrierCommandCloseEventsCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierCommandCloseEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCommandCloseEventsCommandParams + ); + result.put("readBarrierCommandCloseEventsAttribute", readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); + Map readBarrierControlBarrierOpenPeriodCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierOpenPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierOpenPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierOpenPeriodCommandParams + ); + result.put("readBarrierOpenPeriodAttribute", readBarrierControlBarrierOpenPeriodAttributeInteractionInfo); + Map readBarrierControlBarrierClosePeriodCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierClosePeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierClosePeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierClosePeriodCommandParams + ); + result.put("readBarrierClosePeriodAttribute", readBarrierControlBarrierClosePeriodAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams + ); + result.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BarrierControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterGeneratedCommandListAttributeCallback(), + readBarrierControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBarrierControlGeneratedCommandListAttributeInteractionInfo); + Map readBarrierControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BarrierControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAcceptedCommandListAttributeCallback(), + readBarrierControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBarrierControlAcceptedCommandListAttributeInteractionInfo); + Map readBarrierControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readEventListAttribute( + (ChipClusters.BarrierControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterEventListAttributeCallback(), + readBarrierControlEventListCommandParams + ); + result.put("readEventListAttribute", readBarrierControlEventListAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBarrierControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBarrierControlFeatureMapAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPumpConfigurationAndControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxPressureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxPressureAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams + ); + result.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxSpeedAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxSpeedAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams + ); + result.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxFlowAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxFlowAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams + ); + result.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MinConstPressureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstPressureAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams + ); + result.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxConstPressureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstPressureAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams + ); + result.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MinCompPressureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinCompPressureAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams + ); + result.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxCompPressureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxCompPressureAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams + ); + result.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MinConstSpeedAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstSpeedAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams + ); + result.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxConstSpeedAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstSpeedAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams + ); + result.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MinConstFlowAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstFlowAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams + ); + result.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxConstFlowAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstFlowAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams + ); + result.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MinConstTempAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstTempAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams + ); + result.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxConstTempAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstTempAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams + ); + result.put("readMaxConstTempAttribute", readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlPumpStatusCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPumpStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlPumpStatusCommandParams + ); + result.put("readPumpStatusAttribute", readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo); + Map readPumpConfigurationAndControlEffectiveOperationModeCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readEffectiveOperationModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlEffectiveOperationModeCommandParams + ); + result.put("readEffectiveOperationModeAttribute", readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlEffectiveControlModeCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readEffectiveControlModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlEffectiveControlModeCommandParams + ); + result.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.CapacityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterCapacityAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams + ); + result.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.SpeedAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterSpeedAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams + ); + result.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterLifetimeRunningHoursAttributeCallback(), + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams + ); + result.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.PowerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterPowerAttributeCallback(), + readPumpConfigurationAndControlPowerCommandParams + ); + result.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterLifetimeEnergyConsumedAttributeCallback(), + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams + ); + result.put("readLifetimeEnergyConsumedAttribute", readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); + Map readPumpConfigurationAndControlOperationModeCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlOperationModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readOperationModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlOperationModeCommandParams + ); + result.put("readOperationModeAttribute", readPumpConfigurationAndControlOperationModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlControlModeCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlControlModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readControlModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlControlModeCommandParams + ); + result.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterGeneratedCommandListAttributeCallback(), + readPumpConfigurationAndControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo); + Map readPumpConfigurationAndControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAcceptedCommandListAttributeCallback(), + readPumpConfigurationAndControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo); + Map readPumpConfigurationAndControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readEventListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterEventListAttributeCallback(), + readPumpConfigurationAndControlEventListCommandParams + ); + result.put("readEventListAttribute", readPumpConfigurationAndControlEventListAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); + Map readPumpConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPumpConfigurationAndControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo); + Map readPumpConfigurationAndControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readThermostatInteractionInfo() { + Map result = new LinkedHashMap<>();Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( + (ChipClusters.ThermostatCluster.LocalTemperatureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterLocalTemperatureAttributeCallback(), + readThermostatLocalTemperatureCommandParams + ); + result.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatOutdoorTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOutdoorTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOutdoorTemperatureAttribute( + (ChipClusters.ThermostatCluster.OutdoorTemperatureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterOutdoorTemperatureAttributeCallback(), + readThermostatOutdoorTemperatureCommandParams + ); + result.put("readOutdoorTemperatureAttribute", readThermostatOutdoorTemperatureAttributeInteractionInfo); + Map readThermostatOccupancyCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupancyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupancyAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupancyCommandParams + ); + result.put("readOccupancyAttribute", readThermostatOccupancyAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams + ); + result.put("readAbsMinHeatSetpointLimitAttribute", readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatAbsMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAbsMaxHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMaxHeatSetpointLimitCommandParams + ); + result.put("readAbsMaxHeatSetpointLimitAttribute", readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatAbsMinCoolSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAbsMinCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinCoolSetpointLimitCommandParams + ); + result.put("readAbsMinCoolSetpointLimitAttribute", readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatAbsMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAbsMaxCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMaxCoolSetpointLimitCommandParams + ); + result.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatPICoolingDemandCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatPICoolingDemandAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readPICoolingDemandAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatPICoolingDemandCommandParams + ); + result.put("readPICoolingDemandAttribute", readThermostatPICoolingDemandAttributeInteractionInfo); + Map readThermostatPIHeatingDemandCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatPIHeatingDemandAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readPIHeatingDemandAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatPIHeatingDemandCommandParams + ); + result.put("readPIHeatingDemandAttribute", readThermostatPIHeatingDemandAttributeInteractionInfo); + Map readThermostatHVACSystemTypeConfigurationCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readHVACSystemTypeConfigurationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatHVACSystemTypeConfigurationCommandParams + ); + result.put("readHVACSystemTypeConfigurationAttribute", readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); + Map readThermostatLocalTemperatureCalibrationCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureCalibrationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureCalibrationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCalibrationCommandParams + ); + result.put("readLocalTemperatureCalibrationAttribute", readThermostatLocalTemperatureCalibrationAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams + ); + result.put("readOccupiedCoolingSetpointAttribute", readThermostatOccupiedCoolingSetpointAttributeInteractionInfo); + Map readThermostatOccupiedHeatingSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedHeatingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedHeatingSetpointCommandParams + ); + result.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatUnoccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUnoccupiedCoolingSetpointCommandParams + ); + result.put("readUnoccupiedCoolingSetpointAttribute", readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); + Map readThermostatUnoccupiedHeatingSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedHeatingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUnoccupiedHeatingSetpointCommandParams + ); + result.put("readUnoccupiedHeatingSetpointAttribute", readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams + ); + result.put("readMinHeatSetpointLimitAttribute", readThermostatMinHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMaxHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMaxHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMaxHeatSetpointLimitCommandParams + ); + result.put("readMaxHeatSetpointLimitAttribute", readThermostatMaxHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatMinCoolSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMinCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMinCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinCoolSetpointLimitCommandParams + ); + result.put("readMinCoolSetpointLimitAttribute", readThermostatMinCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMaxCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMaxCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMaxCoolSetpointLimitCommandParams + ); + result.put("readMaxCoolSetpointLimitAttribute", readThermostatMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatMinSetpointDeadBandCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMinSetpointDeadBandAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMinSetpointDeadBandAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinSetpointDeadBandCommandParams + ); + result.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatRemoteSensingCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatRemoteSensingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readRemoteSensingAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatRemoteSensingCommandParams + ); + result.put("readRemoteSensingAttribute", readThermostatRemoteSensingAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams + ); + result.put("readControlSequenceOfOperationAttribute", readThermostatControlSequenceOfOperationAttributeInteractionInfo); + Map readThermostatSystemModeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatSystemModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readSystemModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatSystemModeCommandParams + ); + result.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatThermostatRunningModeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatThermostatRunningModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readThermostatRunningModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatThermostatRunningModeCommandParams + ); + result.put("readThermostatRunningModeAttribute", readThermostatThermostatRunningModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams + ); + result.put("readStartOfWeekAttribute", readThermostatStartOfWeekAttributeInteractionInfo); + Map readThermostatNumberOfWeeklyTransitionsCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readNumberOfWeeklyTransitionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatNumberOfWeeklyTransitionsCommandParams + ); + result.put("readNumberOfWeeklyTransitionsAttribute", readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo); + Map readThermostatNumberOfDailyTransitionsCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatNumberOfDailyTransitionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readNumberOfDailyTransitionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatNumberOfDailyTransitionsCommandParams + ); + result.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatTemperatureSetpointHoldCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatTemperatureSetpointHoldAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readTemperatureSetpointHoldAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatTemperatureSetpointHoldCommandParams + ); + result.put("readTemperatureSetpointHoldAttribute", readThermostatTemperatureSetpointHoldAttributeInteractionInfo); + Map readThermostatTemperatureSetpointHoldDurationCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readTemperatureSetpointHoldDurationAttribute( + (ChipClusters.ThermostatCluster.TemperatureSetpointHoldDurationAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterTemperatureSetpointHoldDurationAttributeCallback(), + readThermostatTemperatureSetpointHoldDurationCommandParams + ); + result.put("readTemperatureSetpointHoldDurationAttribute", readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); + Map readThermostatThermostatProgrammingOperationModeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readThermostatProgrammingOperationModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatThermostatProgrammingOperationModeCommandParams + ); + result.put("readThermostatProgrammingOperationModeAttribute", readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); + Map readThermostatThermostatRunningStateCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatThermostatRunningStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readThermostatRunningStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatThermostatRunningStateCommandParams + ); + result.put("readThermostatRunningStateAttribute", readThermostatThermostatRunningStateAttributeInteractionInfo); + Map readThermostatSetpointChangeSourceCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatSetpointChangeSourceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readSetpointChangeSourceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatSetpointChangeSourceCommandParams + ); + result.put("readSetpointChangeSourceAttribute", readThermostatSetpointChangeSourceAttributeInteractionInfo); + Map readThermostatSetpointChangeAmountCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatSetpointChangeAmountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readSetpointChangeAmountAttribute( + (ChipClusters.ThermostatCluster.SetpointChangeAmountAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterSetpointChangeAmountAttributeCallback(), + readThermostatSetpointChangeAmountCommandParams + ); + result.put("readSetpointChangeAmountAttribute", readThermostatSetpointChangeAmountAttributeInteractionInfo); + Map readThermostatSetpointChangeSourceTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readSetpointChangeSourceTimestampAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatSetpointChangeSourceTimestampCommandParams + ); + result.put("readSetpointChangeSourceTimestampAttribute", readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo); + Map readThermostatOccupiedSetbackCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedSetbackAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedSetbackAttribute( + (ChipClusters.ThermostatCluster.OccupiedSetbackAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackAttributeCallback(), + readThermostatOccupiedSetbackCommandParams + ); + result.put("readOccupiedSetbackAttribute", readThermostatOccupiedSetbackAttributeInteractionInfo); + Map readThermostatOccupiedSetbackMinCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedSetbackMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedSetbackMinAttribute( + (ChipClusters.ThermostatCluster.OccupiedSetbackMinAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackMinAttributeCallback(), + readThermostatOccupiedSetbackMinCommandParams + ); + result.put("readOccupiedSetbackMinAttribute", readThermostatOccupiedSetbackMinAttributeInteractionInfo); + Map readThermostatOccupiedSetbackMaxCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedSetbackMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedSetbackMaxAttribute( + (ChipClusters.ThermostatCluster.OccupiedSetbackMaxAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackMaxAttributeCallback(), + readThermostatOccupiedSetbackMaxCommandParams + ); + result.put("readOccupiedSetbackMaxAttribute", readThermostatOccupiedSetbackMaxAttributeInteractionInfo); + Map readThermostatUnoccupiedSetbackCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedSetbackAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedSetbackAttribute( + (ChipClusters.ThermostatCluster.UnoccupiedSetbackAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterUnoccupiedSetbackAttributeCallback(), + readThermostatUnoccupiedSetbackCommandParams + ); + result.put("readUnoccupiedSetbackAttribute", readThermostatUnoccupiedSetbackAttributeInteractionInfo); + Map readThermostatUnoccupiedSetbackMinCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedSetbackMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedSetbackMinAttribute( + (ChipClusters.ThermostatCluster.UnoccupiedSetbackMinAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterUnoccupiedSetbackMinAttributeCallback(), + readThermostatUnoccupiedSetbackMinCommandParams + ); + result.put("readUnoccupiedSetbackMinAttribute", readThermostatUnoccupiedSetbackMinAttributeInteractionInfo); + Map readThermostatUnoccupiedSetbackMaxCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedSetbackMaxAttribute( + (ChipClusters.ThermostatCluster.UnoccupiedSetbackMaxAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterUnoccupiedSetbackMaxAttributeCallback(), + readThermostatUnoccupiedSetbackMaxCommandParams + ); + result.put("readUnoccupiedSetbackMaxAttribute", readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo); + Map readThermostatEmergencyHeatDeltaCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatEmergencyHeatDeltaAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readEmergencyHeatDeltaAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatEmergencyHeatDeltaCommandParams + ); + result.put("readEmergencyHeatDeltaAttribute", readThermostatEmergencyHeatDeltaAttributeInteractionInfo); + Map readThermostatACTypeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACTypeCommandParams + ); + result.put("readACTypeAttribute", readThermostatACTypeAttributeInteractionInfo); + Map readThermostatACCapacityCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACCapacityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACCapacityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACCapacityCommandParams + ); + result.put("readACCapacityAttribute", readThermostatACCapacityAttributeInteractionInfo); + Map readThermostatACRefrigerantTypeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACRefrigerantTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACRefrigerantTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACRefrigerantTypeCommandParams + ); + result.put("readACRefrigerantTypeAttribute", readThermostatACRefrigerantTypeAttributeInteractionInfo); + Map readThermostatACCompressorTypeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACCompressorTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACCompressorTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACCompressorTypeCommandParams + ); + result.put("readACCompressorTypeAttribute", readThermostatACCompressorTypeAttributeInteractionInfo); + Map readThermostatACErrorCodeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACErrorCodeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACErrorCodeAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatACErrorCodeCommandParams + ); + result.put("readACErrorCodeAttribute", readThermostatACErrorCodeAttributeInteractionInfo); + Map readThermostatACLouverPositionCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACLouverPositionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACLouverPositionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACLouverPositionCommandParams + ); + result.put("readACLouverPositionAttribute", readThermostatACLouverPositionAttributeInteractionInfo); + Map readThermostatACCoilTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACCoilTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACCoilTemperatureAttribute( + (ChipClusters.ThermostatCluster.ACCoilTemperatureAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterACCoilTemperatureAttributeCallback(), + readThermostatACCoilTemperatureCommandParams + ); + result.put("readACCoilTemperatureAttribute", readThermostatACCoilTemperatureAttributeInteractionInfo); + Map readThermostatACCapacityformatCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatACCapacityformatAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readACCapacityformatAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACCapacityformatCommandParams + ); + result.put("readACCapacityformatAttribute", readThermostatACCapacityformatAttributeInteractionInfo); + Map readThermostatGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ThermostatCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterGeneratedCommandListAttributeCallback(), + readThermostatGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readThermostatGeneratedCommandListAttributeInteractionInfo); + Map readThermostatAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ThermostatCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterAcceptedCommandListAttributeCallback(), + readThermostatAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readThermostatAcceptedCommandListAttributeInteractionInfo); + Map readThermostatEventListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readEventListAttribute( + (ChipClusters.ThermostatCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterEventListAttributeCallback(), + readThermostatEventListCommandParams + ); + result.put("readEventListAttribute", readThermostatEventListAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( + (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), + readThermostatAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); + Map readThermostatFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readThermostatFeatureMapAttributeInteractionInfo); + Map readThermostatClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFanControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFanControlFanModeCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlFanModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readFanModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlFanModeCommandParams + ); + result.put("readFanModeAttribute", readFanControlFanModeAttributeInteractionInfo); + Map readFanControlFanModeSequenceCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlFanModeSequenceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readFanModeSequenceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlFanModeSequenceCommandParams + ); + result.put("readFanModeSequenceAttribute", readFanControlFanModeSequenceAttributeInteractionInfo); + Map readFanControlPercentSettingCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlPercentSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readPercentSettingAttribute( + (ChipClusters.FanControlCluster.PercentSettingAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterPercentSettingAttributeCallback(), + readFanControlPercentSettingCommandParams + ); + result.put("readPercentSettingAttribute", readFanControlPercentSettingAttributeInteractionInfo); + Map readFanControlPercentCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlPercentCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readPercentCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlPercentCurrentCommandParams + ); + result.put("readPercentCurrentAttribute", readFanControlPercentCurrentAttributeInteractionInfo); + Map readFanControlSpeedMaxCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlSpeedMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readSpeedMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlSpeedMaxCommandParams + ); + result.put("readSpeedMaxAttribute", readFanControlSpeedMaxAttributeInteractionInfo); + Map readFanControlSpeedSettingCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlSpeedSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readSpeedSettingAttribute( + (ChipClusters.FanControlCluster.SpeedSettingAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterSpeedSettingAttributeCallback(), + readFanControlSpeedSettingCommandParams + ); + result.put("readSpeedSettingAttribute", readFanControlSpeedSettingAttributeInteractionInfo); + Map readFanControlSpeedCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlSpeedCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readSpeedCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlSpeedCurrentCommandParams + ); + result.put("readSpeedCurrentAttribute", readFanControlSpeedCurrentAttributeInteractionInfo); + Map readFanControlRockSupportCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlRockSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readRockSupportAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlRockSupportCommandParams + ); + result.put("readRockSupportAttribute", readFanControlRockSupportAttributeInteractionInfo); + Map readFanControlRockSettingCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlRockSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readRockSettingAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlRockSettingCommandParams + ); + result.put("readRockSettingAttribute", readFanControlRockSettingAttributeInteractionInfo); + Map readFanControlWindSupportCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlWindSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readWindSupportAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlWindSupportCommandParams + ); + result.put("readWindSupportAttribute", readFanControlWindSupportAttributeInteractionInfo); + Map readFanControlWindSettingCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlWindSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readWindSettingAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlWindSettingCommandParams + ); + result.put("readWindSettingAttribute", readFanControlWindSettingAttributeInteractionInfo); + Map readFanControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FanControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterGeneratedCommandListAttributeCallback(), + readFanControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFanControlGeneratedCommandListAttributeInteractionInfo); + Map readFanControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FanControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterAcceptedCommandListAttributeCallback(), + readFanControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFanControlAcceptedCommandListAttributeInteractionInfo); + Map readFanControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readEventListAttribute( + (ChipClusters.FanControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterEventListAttributeCallback(), + readFanControlEventListCommandParams + ); + result.put("readEventListAttribute", readFanControlEventListAttributeInteractionInfo); + Map readFanControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.FanControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterAttributeListAttributeCallback(), + readFanControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFanControlAttributeListAttributeInteractionInfo); + Map readFanControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFanControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFanControlFeatureMapAttributeInteractionInfo); + Map readFanControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFanControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFanControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readThermostatUserInterfaceConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams + ); + result.put("readTemperatureDisplayModeAttribute", readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readKeypadLockoutAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams + ); + result.put("readKeypadLockoutAttribute", readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readScheduleProgrammingVisibilityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams + ); + result.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterGeneratedCommandListAttributeCallback(), + readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAcceptedCommandListAttributeCallback(), + readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterEventListAttributeCallback(), + readThermostatUserInterfaceConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatUserInterfaceConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readColorControlInteractionInfo() { + Map result = new LinkedHashMap<>();Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams + ); + result.put("readCurrentHueAttribute", readColorControlCurrentHueAttributeInteractionInfo); + Map readColorControlCurrentSaturationCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCurrentSaturationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCurrentSaturationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentSaturationCommandParams + ); + result.put("readCurrentSaturationAttribute", readColorControlCurrentSaturationAttributeInteractionInfo); + Map readColorControlRemainingTimeCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlRemainingTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readRemainingTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlRemainingTimeCommandParams + ); + result.put("readRemainingTimeAttribute", readColorControlRemainingTimeAttributeInteractionInfo); + Map readColorControlCurrentXCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCurrentXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCurrentXAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentXCommandParams + ); + result.put("readCurrentXAttribute", readColorControlCurrentXAttributeInteractionInfo); + Map readColorControlCurrentYCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCurrentYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCurrentYAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentYCommandParams + ); + result.put("readCurrentYAttribute", readColorControlCurrentYAttributeInteractionInfo); + Map readColorControlDriftCompensationCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlDriftCompensationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readDriftCompensationAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlDriftCompensationCommandParams + ); + result.put("readDriftCompensationAttribute", readColorControlDriftCompensationAttributeInteractionInfo); + Map readColorControlCompensationTextCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCompensationTextAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readColorControlCompensationTextCommandParams + ); + result.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureMiredsCommandParams + ); + result.put("readColorTemperatureMiredsAttribute", readColorControlColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams + ); + result.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlOptionsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readOptionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlOptionsCommandParams + ); + result.put("readOptionsAttribute", readColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( + (ChipClusters.ColorControlCluster.NumberOfPrimariesAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterNumberOfPrimariesAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams + ); + result.put("readNumberOfPrimariesAttribute", readColorControlNumberOfPrimariesAttributeInteractionInfo); + Map readColorControlPrimary1XCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary1XAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary1XAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1XCommandParams + ); + result.put("readPrimary1XAttribute", readColorControlPrimary1XAttributeInteractionInfo); + Map readColorControlPrimary1YCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary1YAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary1YAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1YCommandParams + ); + result.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary1IntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary1IntensityAttributeCallback(), + readColorControlPrimary1IntensityCommandParams + ); + result.put("readPrimary1IntensityAttribute", readColorControlPrimary1IntensityAttributeInteractionInfo); + Map readColorControlPrimary2XCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary2XAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary2XAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2XCommandParams + ); + result.put("readPrimary2XAttribute", readColorControlPrimary2XAttributeInteractionInfo); + Map readColorControlPrimary2YCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary2YAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary2YAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2YCommandParams + ); + result.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary2IntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary2IntensityAttributeCallback(), + readColorControlPrimary2IntensityCommandParams + ); + result.put("readPrimary2IntensityAttribute", readColorControlPrimary2IntensityAttributeInteractionInfo); + Map readColorControlPrimary3XCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary3XAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary3XAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3XCommandParams + ); + result.put("readPrimary3XAttribute", readColorControlPrimary3XAttributeInteractionInfo); + Map readColorControlPrimary3YCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary3YAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary3YAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3YCommandParams + ); + result.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary3IntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary3IntensityAttributeCallback(), + readColorControlPrimary3IntensityCommandParams + ); + result.put("readPrimary3IntensityAttribute", readColorControlPrimary3IntensityAttributeInteractionInfo); + Map readColorControlPrimary4XCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary4XAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary4XAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4XCommandParams + ); + result.put("readPrimary4XAttribute", readColorControlPrimary4XAttributeInteractionInfo); + Map readColorControlPrimary4YCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary4YAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary4YAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4YCommandParams + ); + result.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary4IntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary4IntensityAttributeCallback(), + readColorControlPrimary4IntensityCommandParams + ); + result.put("readPrimary4IntensityAttribute", readColorControlPrimary4IntensityAttributeInteractionInfo); + Map readColorControlPrimary5XCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary5XAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary5XAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5XCommandParams + ); + result.put("readPrimary5XAttribute", readColorControlPrimary5XAttributeInteractionInfo); + Map readColorControlPrimary5YCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary5YAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary5YAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5YCommandParams + ); + result.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary5IntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary5IntensityAttributeCallback(), + readColorControlPrimary5IntensityCommandParams + ); + result.put("readPrimary5IntensityAttribute", readColorControlPrimary5IntensityAttributeInteractionInfo); + Map readColorControlPrimary6XCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary6XAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary6XAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6XCommandParams + ); + result.put("readPrimary6XAttribute", readColorControlPrimary6XAttributeInteractionInfo); + Map readColorControlPrimary6YCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary6YAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary6YAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6YCommandParams + ); + result.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary6IntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary6IntensityAttributeCallback(), + readColorControlPrimary6IntensityCommandParams + ); + result.put("readPrimary6IntensityAttribute", readColorControlPrimary6IntensityAttributeInteractionInfo); + Map readColorControlWhitePointXCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlWhitePointXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readWhitePointXAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlWhitePointXCommandParams + ); + result.put("readWhitePointXAttribute", readColorControlWhitePointXAttributeInteractionInfo); + Map readColorControlWhitePointYCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlWhitePointYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readWhitePointYAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlWhitePointYCommandParams + ); + result.put("readWhitePointYAttribute", readColorControlWhitePointYAttributeInteractionInfo); + Map readColorControlColorPointRXCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointRXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointRXAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRXCommandParams + ); + result.put("readColorPointRXAttribute", readColorControlColorPointRXAttributeInteractionInfo); + Map readColorControlColorPointRYCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointRYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointRYAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRYCommandParams + ); + result.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( + (ChipClusters.ColorControlCluster.ColorPointRIntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterColorPointRIntensityAttributeCallback(), + readColorControlColorPointRIntensityCommandParams + ); + result.put("readColorPointRIntensityAttribute", readColorControlColorPointRIntensityAttributeInteractionInfo); + Map readColorControlColorPointGXCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointGXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointGXAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGXCommandParams + ); + result.put("readColorPointGXAttribute", readColorControlColorPointGXAttributeInteractionInfo); + Map readColorControlColorPointGYCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointGYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointGYAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGYCommandParams + ); + result.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( + (ChipClusters.ColorControlCluster.ColorPointGIntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterColorPointGIntensityAttributeCallback(), + readColorControlColorPointGIntensityCommandParams + ); + result.put("readColorPointGIntensityAttribute", readColorControlColorPointGIntensityAttributeInteractionInfo); + Map readColorControlColorPointBXCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointBXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointBXAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBXCommandParams + ); + result.put("readColorPointBXAttribute", readColorControlColorPointBXAttributeInteractionInfo); + Map readColorControlColorPointBYCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointBYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointBYAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBYCommandParams + ); + result.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( + (ChipClusters.ColorControlCluster.ColorPointBIntensityAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterColorPointBIntensityAttributeCallback(), + readColorControlColorPointBIntensityCommandParams + ); + result.put("readColorPointBIntensityAttribute", readColorControlColorPointBIntensityAttributeInteractionInfo); + Map readColorControlEnhancedCurrentHueCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlEnhancedCurrentHueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readEnhancedCurrentHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlEnhancedCurrentHueCommandParams + ); + result.put("readEnhancedCurrentHueAttribute", readColorControlEnhancedCurrentHueAttributeInteractionInfo); + Map readColorControlEnhancedColorModeCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlEnhancedColorModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readEnhancedColorModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlEnhancedColorModeCommandParams + ); + result.put("readEnhancedColorModeAttribute", readColorControlEnhancedColorModeAttributeInteractionInfo); + Map readColorControlColorLoopActiveCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorLoopActiveAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorLoopActiveAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopActiveCommandParams + ); + result.put("readColorLoopActiveAttribute", readColorControlColorLoopActiveAttributeInteractionInfo); + Map readColorControlColorLoopDirectionCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorLoopDirectionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorLoopDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopDirectionCommandParams + ); + result.put("readColorLoopDirectionAttribute", readColorControlColorLoopDirectionAttributeInteractionInfo); + Map readColorControlColorLoopTimeCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorLoopTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorLoopTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopTimeCommandParams + ); + result.put("readColorLoopTimeAttribute", readColorControlColorLoopTimeAttributeInteractionInfo); + Map readColorControlColorLoopStartEnhancedHueCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorLoopStartEnhancedHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopStartEnhancedHueCommandParams + ); + result.put("readColorLoopStartEnhancedHueAttribute", readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo); + Map readColorControlColorLoopStoredEnhancedHueCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorLoopStoredEnhancedHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopStoredEnhancedHueCommandParams + ); + result.put("readColorLoopStoredEnhancedHueAttribute", readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo); + Map readColorControlColorCapabilitiesCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorCapabilitiesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorCapabilitiesAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorCapabilitiesCommandParams + ); + result.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinMiredsCommandParams + ); + result.put("readColorTempPhysicalMinMiredsAttribute", readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxMiredsCommandParams + ); + result.put("readColorTempPhysicalMaxMiredsAttribute", readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams + ); + result.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( + (ChipClusters.ColorControlCluster.StartUpColorTemperatureMiredsAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterStartUpColorTemperatureMiredsAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams + ); + result.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ColorControlCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterGeneratedCommandListAttributeCallback(), + readColorControlGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readColorControlGeneratedCommandListAttributeInteractionInfo); + Map readColorControlAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ColorControlCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterAcceptedCommandListAttributeCallback(), + readColorControlAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readColorControlAcceptedCommandListAttributeInteractionInfo); + Map readColorControlEventListCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readEventListAttribute( + (ChipClusters.ColorControlCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterEventListAttributeCallback(), + readColorControlEventListCommandParams + ); + result.put("readEventListAttribute", readColorControlEventListAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( + (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readColorControlFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readColorControlFeatureMapAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readBallastConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>();Map readBallastConfigurationPhysicalMinLevelCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readPhysicalMinLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationPhysicalMinLevelCommandParams + ); + result.put("readPhysicalMinLevelAttribute", readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo); + Map readBallastConfigurationPhysicalMaxLevelCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readPhysicalMaxLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationPhysicalMaxLevelCommandParams + ); + result.put("readPhysicalMaxLevelAttribute", readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo); + Map readBallastConfigurationBallastStatusCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationBallastStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readBallastStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationBallastStatusCommandParams + ); + result.put("readBallastStatusAttribute", readBallastConfigurationBallastStatusAttributeInteractionInfo); + Map readBallastConfigurationMinLevelCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationMinLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readMinLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationMinLevelCommandParams + ); + result.put("readMinLevelAttribute", readBallastConfigurationMinLevelAttributeInteractionInfo); + Map readBallastConfigurationMaxLevelCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationMaxLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readMaxLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationMaxLevelCommandParams + ); + result.put("readMaxLevelAttribute", readBallastConfigurationMaxLevelAttributeInteractionInfo); + Map readBallastConfigurationIntrinsicBallastFactorCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readIntrinsicBallastFactorAttribute( + (ChipClusters.BallastConfigurationCluster.IntrinsicBallastFactorAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterIntrinsicBallastFactorAttributeCallback(), + readBallastConfigurationIntrinsicBallastFactorCommandParams + ); + result.put("readIntrinsicBallastFactorAttribute", readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); + Map readBallastConfigurationBallastFactorAdjustmentCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readBallastFactorAdjustmentAttribute( + (ChipClusters.BallastConfigurationCluster.BallastFactorAdjustmentAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterBallastFactorAdjustmentAttributeCallback(), + readBallastConfigurationBallastFactorAdjustmentCommandParams + ); + result.put("readBallastFactorAdjustmentAttribute", readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); + Map readBallastConfigurationLampQuantityCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampQuantityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampQuantityAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationLampQuantityCommandParams + ); + result.put("readLampQuantityAttribute", readBallastConfigurationLampQuantityAttributeInteractionInfo); + Map readBallastConfigurationLampTypeCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampTypeAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBallastConfigurationLampTypeCommandParams + ); + result.put("readLampTypeAttribute", readBallastConfigurationLampTypeAttributeInteractionInfo); + Map readBallastConfigurationLampManufacturerCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampManufacturerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampManufacturerAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBallastConfigurationLampManufacturerCommandParams + ); + result.put("readLampManufacturerAttribute", readBallastConfigurationLampManufacturerAttributeInteractionInfo); + Map readBallastConfigurationLampRatedHoursCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampRatedHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampRatedHoursAttribute( + (ChipClusters.BallastConfigurationCluster.LampRatedHoursAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterLampRatedHoursAttributeCallback(), + readBallastConfigurationLampRatedHoursCommandParams + ); + result.put("readLampRatedHoursAttribute", readBallastConfigurationLampRatedHoursAttributeInteractionInfo); + Map readBallastConfigurationLampBurnHoursCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampBurnHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampBurnHoursAttribute( + (ChipClusters.BallastConfigurationCluster.LampBurnHoursAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterLampBurnHoursAttributeCallback(), + readBallastConfigurationLampBurnHoursCommandParams + ); + result.put("readLampBurnHoursAttribute", readBallastConfigurationLampBurnHoursAttributeInteractionInfo); + Map readBallastConfigurationLampAlarmModeCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampAlarmModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampAlarmModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationLampAlarmModeCommandParams + ); + result.put("readLampAlarmModeAttribute", readBallastConfigurationLampAlarmModeAttributeInteractionInfo); + Map readBallastConfigurationLampBurnHoursTripPointCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readLampBurnHoursTripPointAttribute( + (ChipClusters.BallastConfigurationCluster.LampBurnHoursTripPointAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterLampBurnHoursTripPointAttributeCallback(), + readBallastConfigurationLampBurnHoursTripPointCommandParams + ); + result.put("readLampBurnHoursTripPointAttribute", readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); + Map readBallastConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.BallastConfigurationCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterGeneratedCommandListAttributeCallback(), + readBallastConfigurationGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readBallastConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readBallastConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.BallastConfigurationCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterAcceptedCommandListAttributeCallback(), + readBallastConfigurationAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readBallastConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readBallastConfigurationEventListCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readEventListAttribute( + (ChipClusters.BallastConfigurationCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterEventListAttributeCallback(), + readBallastConfigurationEventListCommandParams + ); + result.put("readEventListAttribute", readBallastConfigurationEventListAttributeInteractionInfo); + Map readBallastConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readAttributeListAttribute( + (ChipClusters.BallastConfigurationCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterAttributeListAttributeCallback(), + readBallastConfigurationAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readBallastConfigurationAttributeListAttributeInteractionInfo); + Map readBallastConfigurationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBallastConfigurationFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readBallastConfigurationFeatureMapAttributeInteractionInfo); + Map readBallastConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBallastConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readBallastConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readIlluminanceMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterMeasuredValueAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterMinMeasuredValueAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterMaxMeasuredValueAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementToleranceCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readToleranceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementToleranceCommandParams + ); + result.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( + (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterLightSensorTypeAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams + ); + result.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterGeneratedCommandListAttributeCallback(), + readIlluminanceMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readIlluminanceMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAcceptedCommandListAttributeCallback(), + readIlluminanceMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readIlluminanceMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterEventListAttributeCallback(), + readIlluminanceMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readIlluminanceMeasurementEventListAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIlluminanceMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readIlluminanceMeasurementFeatureMapAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTemperatureMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.TemperatureMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterMeasuredValueAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.TemperatureMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterMinMeasuredValueAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.TemperatureMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterMaxMeasuredValueAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementToleranceCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readToleranceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementToleranceCommandParams + ); + result.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TemperatureMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterGeneratedCommandListAttributeCallback(), + readTemperatureMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readTemperatureMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TemperatureMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAcceptedCommandListAttributeCallback(), + readTemperatureMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readTemperatureMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.TemperatureMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterEventListAttributeCallback(), + readTemperatureMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readTemperatureMeasurementEventListAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTemperatureMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTemperatureMeasurementFeatureMapAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readPressureMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.PressureMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMeasuredValueAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.PressureMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMinMeasuredValueAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.PressureMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMaxMeasuredValueAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementToleranceCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readToleranceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementToleranceCommandParams + ); + result.put("readToleranceAttribute", readPressureMeasurementToleranceAttributeInteractionInfo); + Map readPressureMeasurementScaledValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementScaledValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readScaledValueAttribute( + (ChipClusters.PressureMeasurementCluster.ScaledValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterScaledValueAttributeCallback(), + readPressureMeasurementScaledValueCommandParams + ); + result.put("readScaledValueAttribute", readPressureMeasurementScaledValueAttributeInteractionInfo); + Map readPressureMeasurementMinScaledValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinScaledValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMinScaledValueAttribute( + (ChipClusters.PressureMeasurementCluster.MinScaledValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMinScaledValueAttributeCallback(), + readPressureMeasurementMinScaledValueCommandParams + ); + result.put("readMinScaledValueAttribute", readPressureMeasurementMinScaledValueAttributeInteractionInfo); + Map readPressureMeasurementMaxScaledValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxScaledValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMaxScaledValueAttribute( + (ChipClusters.PressureMeasurementCluster.MaxScaledValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMaxScaledValueAttributeCallback(), + readPressureMeasurementMaxScaledValueCommandParams + ); + result.put("readMaxScaledValueAttribute", readPressureMeasurementMaxScaledValueAttributeInteractionInfo); + Map readPressureMeasurementScaledToleranceCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementScaledToleranceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readScaledToleranceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementScaledToleranceCommandParams + ); + result.put("readScaledToleranceAttribute", readPressureMeasurementScaledToleranceAttributeInteractionInfo); + Map readPressureMeasurementScaleCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementScaleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readScaleAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementScaleCommandParams + ); + result.put("readScaleAttribute", readPressureMeasurementScaleAttributeInteractionInfo); + Map readPressureMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.PressureMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterGeneratedCommandListAttributeCallback(), + readPressureMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readPressureMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readPressureMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.PressureMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAcceptedCommandListAttributeCallback(), + readPressureMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readPressureMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readPressureMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.PressureMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterEventListAttributeCallback(), + readPressureMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readPressureMeasurementEventListAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPressureMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readPressureMeasurementFeatureMapAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFlowMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.FlowMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterMeasuredValueAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.FlowMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterMinMeasuredValueAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.FlowMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterMaxMeasuredValueAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementToleranceCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readToleranceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementToleranceCommandParams + ); + result.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FlowMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterGeneratedCommandListAttributeCallback(), + readFlowMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFlowMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readFlowMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FlowMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAcceptedCommandListAttributeCallback(), + readFlowMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFlowMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readFlowMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.FlowMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterEventListAttributeCallback(), + readFlowMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readFlowMeasurementEventListAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFlowMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFlowMeasurementFeatureMapAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readRelativeHumidityMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.MeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterMeasuredValueAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams + ); + result.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.MinMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterMinMeasuredValueAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams + ); + result.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.MaxMeasuredValueAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterMaxMeasuredValueAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams + ); + result.put("readMaxMeasuredValueAttribute", readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementToleranceCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readToleranceAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementToleranceCommandParams + ); + result.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map readRelativeHumidityMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterGeneratedCommandListAttributeCallback(), + readRelativeHumidityMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAcceptedCommandListAttributeCallback(), + readRelativeHumidityMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterEventListAttributeCallback(), + readRelativeHumidityMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readRelativeHumidityMeasurementEventListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRelativeHumidityMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readOccupancySensingInteractionInfo() { + Map result = new LinkedHashMap<>();Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams + ); + result.put("readOccupancyAttribute", readOccupancySensingOccupancyAttributeInteractionInfo); + Map readOccupancySensingOccupancySensorTypeCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancySensorTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readOccupancySensorTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancySensorTypeCommandParams + ); + result.put("readOccupancySensorTypeAttribute", readOccupancySensingOccupancySensorTypeAttributeInteractionInfo); + Map readOccupancySensingOccupancySensorTypeBitmapCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readOccupancySensorTypeBitmapAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancySensorTypeBitmapCommandParams + ); + result.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readPIROccupiedToUnoccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams + ); + result.put("readPIROccupiedToUnoccupiedDelayAttribute", readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readPIRUnoccupiedToOccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams + ); + result.put("readPIRUnoccupiedToOccupiedDelayAttribute", readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readPIRUnoccupiedToOccupiedThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams + ); + result.put("readPIRUnoccupiedToOccupiedThresholdAttribute", readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readUltrasonicOccupiedToUnoccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams + ); + result.put("readUltrasonicOccupiedToUnoccupiedDelayAttribute", readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readUltrasonicUnoccupiedToOccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams + ); + result.put("readUltrasonicUnoccupiedToOccupiedDelayAttribute", readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readUltrasonicUnoccupiedToOccupiedThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams + ); + result.put("readUltrasonicUnoccupiedToOccupiedThresholdAttribute", readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readPhysicalContactOccupiedToUnoccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams + ); + result.put("readPhysicalContactOccupiedToUnoccupiedDelayAttribute", readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readPhysicalContactUnoccupiedToOccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams + ); + result.put("readPhysicalContactUnoccupiedToOccupiedDelayAttribute", readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readPhysicalContactUnoccupiedToOccupiedThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams + ); + result.put("readPhysicalContactUnoccupiedToOccupiedThresholdAttribute", readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map readOccupancySensingGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.OccupancySensingCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterGeneratedCommandListAttributeCallback(), + readOccupancySensingGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readOccupancySensingGeneratedCommandListAttributeInteractionInfo); + Map readOccupancySensingAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.OccupancySensingCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAcceptedCommandListAttributeCallback(), + readOccupancySensingAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readOccupancySensingAcceptedCommandListAttributeInteractionInfo); + Map readOccupancySensingEventListCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readEventListAttribute( + (ChipClusters.OccupancySensingCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterEventListAttributeCallback(), + readOccupancySensingEventListCommandParams + ); + result.put("readEventListAttribute", readOccupancySensingEventListAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( + (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOccupancySensingFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readOccupancySensingFeatureMapAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readWakeOnLanInteractionInfo() { + Map result = new LinkedHashMap<>();Map readWakeOnLanMACAddressCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanMACAddressAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readMACAddressAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readWakeOnLanMACAddressCommandParams + ); + result.put("readMACAddressAttribute", readWakeOnLanMACAddressAttributeInteractionInfo); + Map readWakeOnLanGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.WakeOnLanCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterGeneratedCommandListAttributeCallback(), + readWakeOnLanGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readWakeOnLanGeneratedCommandListAttributeInteractionInfo); + Map readWakeOnLanAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.WakeOnLanCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAcceptedCommandListAttributeCallback(), + readWakeOnLanAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readWakeOnLanAcceptedCommandListAttributeInteractionInfo); + Map readWakeOnLanEventListCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readEventListAttribute( + (ChipClusters.WakeOnLanCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterEventListAttributeCallback(), + readWakeOnLanEventListCommandParams + ); + result.put("readEventListAttribute", readWakeOnLanEventListAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( + (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), + readWakeOnLanAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWakeOnLanFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readWakeOnLanFeatureMapAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readChannelInteractionInfo() { + Map result = new LinkedHashMap<>();Map readChannelChannelListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelChannelListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readChannelListAttribute( + (ChipClusters.ChannelCluster.ChannelListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterChannelListAttributeCallback(), + readChannelChannelListCommandParams + ); + result.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ChannelCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterGeneratedCommandListAttributeCallback(), + readChannelGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readChannelGeneratedCommandListAttributeInteractionInfo); + Map readChannelAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ChannelCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterAcceptedCommandListAttributeCallback(), + readChannelAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readChannelAcceptedCommandListAttributeInteractionInfo); + Map readChannelEventListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readEventListAttribute( + (ChipClusters.ChannelCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterEventListAttributeCallback(), + readChannelEventListCommandParams + ); + result.put("readEventListAttribute", readChannelEventListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( + (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), + readChannelAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readChannelFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChannelFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readChannelFeatureMapAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readTargetNavigatorInteractionInfo() { + Map result = new LinkedHashMap<>();Map readTargetNavigatorTargetListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readTargetListAttribute( + (ChipClusters.TargetNavigatorCluster.TargetListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetListAttributeCallback(), + readTargetNavigatorTargetListCommandParams + ); + result.put("readTargetListAttribute", readTargetNavigatorTargetListAttributeInteractionInfo); + Map readTargetNavigatorCurrentTargetCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentTargetAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentTargetAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentTargetCommandParams + ); + result.put("readCurrentTargetAttribute", readTargetNavigatorCurrentTargetAttributeInteractionInfo); + Map readTargetNavigatorGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.TargetNavigatorCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterGeneratedCommandListAttributeCallback(), + readTargetNavigatorGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readTargetNavigatorGeneratedCommandListAttributeInteractionInfo); + Map readTargetNavigatorAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.TargetNavigatorCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAcceptedCommandListAttributeCallback(), + readTargetNavigatorAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readTargetNavigatorAcceptedCommandListAttributeInteractionInfo); + Map readTargetNavigatorEventListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readEventListAttribute( + (ChipClusters.TargetNavigatorCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterEventListAttributeCallback(), + readTargetNavigatorEventListCommandParams + ); + result.put("readEventListAttribute", readTargetNavigatorEventListAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( + (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTargetNavigatorFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readTargetNavigatorFeatureMapAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readMediaPlaybackInteractionInfo() { + Map result = new LinkedHashMap<>();Map readMediaPlaybackCurrentStateCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackCurrentStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readCurrentStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackCurrentStateCommandParams + ); + result.put("readCurrentStateAttribute", readMediaPlaybackCurrentStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( + (ChipClusters.MediaPlaybackCluster.StartTimeAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterStartTimeAttributeCallback(), + readMediaPlaybackStartTimeCommandParams + ); + result.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( + (ChipClusters.MediaPlaybackCluster.DurationAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterDurationAttributeCallback(), + readMediaPlaybackDurationCommandParams + ); + result.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); + Map readMediaPlaybackPlaybackSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackSpeedAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readMediaPlaybackPlaybackSpeedCommandParams + ); + result.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( + (ChipClusters.MediaPlaybackCluster.SeekRangeEndAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterSeekRangeEndAttributeCallback(), + readMediaPlaybackSeekRangeEndCommandParams + ); + result.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( + (ChipClusters.MediaPlaybackCluster.SeekRangeStartAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterSeekRangeStartAttributeCallback(), + readMediaPlaybackSeekRangeStartCommandParams + ); + result.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.MediaPlaybackCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterGeneratedCommandListAttributeCallback(), + readMediaPlaybackGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readMediaPlaybackGeneratedCommandListAttributeInteractionInfo); + Map readMediaPlaybackAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.MediaPlaybackCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAcceptedCommandListAttributeCallback(), + readMediaPlaybackAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readMediaPlaybackAcceptedCommandListAttributeInteractionInfo); + Map readMediaPlaybackEventListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readEventListAttribute( + (ChipClusters.MediaPlaybackCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterEventListAttributeCallback(), + readMediaPlaybackEventListCommandParams + ); + result.put("readEventListAttribute", readMediaPlaybackEventListAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( + (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readMediaPlaybackFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readMediaPlaybackFeatureMapAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readMediaInputInteractionInfo() { + Map result = new LinkedHashMap<>();Map readMediaInputInputListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputInputListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readInputListAttribute( + (ChipClusters.MediaInputCluster.InputListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterInputListAttributeCallback(), + readMediaInputInputListCommandParams + ); + result.put("readInputListAttribute", readMediaInputInputListAttributeInteractionInfo); + Map readMediaInputCurrentInputCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputCurrentInputAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readCurrentInputAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentInputCommandParams + ); + result.put("readCurrentInputAttribute", readMediaInputCurrentInputAttributeInteractionInfo); + Map readMediaInputGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.MediaInputCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterGeneratedCommandListAttributeCallback(), + readMediaInputGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readMediaInputGeneratedCommandListAttributeInteractionInfo); + Map readMediaInputAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.MediaInputCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterAcceptedCommandListAttributeCallback(), + readMediaInputAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readMediaInputAcceptedCommandListAttributeInteractionInfo); + Map readMediaInputEventListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readEventListAttribute( + (ChipClusters.MediaInputCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterEventListAttributeCallback(), + readMediaInputEventListCommandParams + ); + result.put("readEventListAttribute", readMediaInputEventListAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( + (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), + readMediaInputAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readMediaInputFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readMediaInputFeatureMapAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readLowPowerInteractionInfo() { + Map result = new LinkedHashMap<>();Map readLowPowerGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.LowPowerCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLowPowerClusterGeneratedCommandListAttributeCallback(), + readLowPowerGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readLowPowerGeneratedCommandListAttributeInteractionInfo); + Map readLowPowerAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.LowPowerCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLowPowerClusterAcceptedCommandListAttributeCallback(), + readLowPowerAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readLowPowerAcceptedCommandListAttributeInteractionInfo); + Map readLowPowerEventListCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readEventListAttribute( + (ChipClusters.LowPowerCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLowPowerClusterEventListAttributeCallback(), + readLowPowerEventListCommandParams + ); + result.put("readEventListAttribute", readLowPowerEventListAttributeInteractionInfo); + Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( + (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), + readLowPowerAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLowPowerFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readLowPowerFeatureMapAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readKeypadInputInteractionInfo() { + Map result = new LinkedHashMap<>();Map readKeypadInputGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.KeypadInputCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterGeneratedCommandListAttributeCallback(), + readKeypadInputGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readKeypadInputGeneratedCommandListAttributeInteractionInfo); + Map readKeypadInputAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.KeypadInputCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAcceptedCommandListAttributeCallback(), + readKeypadInputAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readKeypadInputAcceptedCommandListAttributeInteractionInfo); + Map readKeypadInputEventListCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readEventListAttribute( + (ChipClusters.KeypadInputCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterEventListAttributeCallback(), + readKeypadInputEventListCommandParams + ); + result.put("readEventListAttribute", readKeypadInputEventListAttributeInteractionInfo); + Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( + (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readKeypadInputFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readKeypadInputFeatureMapAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readContentLauncherInteractionInfo() { + Map result = new LinkedHashMap<>();Map readContentLauncherAcceptHeaderCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderAttribute( + (ChipClusters.ContentLauncherCluster.AcceptHeaderAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderAttributeCallback(), + readContentLauncherAcceptHeaderCommandParams + ); + result.put("readAcceptHeaderAttribute", readContentLauncherAcceptHeaderAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readContentLauncherSupportedStreamingProtocolsCommandParams + ); + result.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ContentLauncherCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterGeneratedCommandListAttributeCallback(), + readContentLauncherGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readContentLauncherGeneratedCommandListAttributeInteractionInfo); + Map readContentLauncherAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ContentLauncherCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptedCommandListAttributeCallback(), + readContentLauncherAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readContentLauncherAcceptedCommandListAttributeInteractionInfo); + Map readContentLauncherEventListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readEventListAttribute( + (ChipClusters.ContentLauncherCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterEventListAttributeCallback(), + readContentLauncherEventListCommandParams + ); + result.put("readEventListAttribute", readContentLauncherEventListAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( + (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readContentLauncherFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readContentLauncherFeatureMapAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readAudioOutputInteractionInfo() { + Map result = new LinkedHashMap<>();Map readAudioOutputOutputListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputOutputListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readOutputListAttribute( + (ChipClusters.AudioOutputCluster.OutputListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterOutputListAttributeCallback(), + readAudioOutputOutputListCommandParams + ); + result.put("readOutputListAttribute", readAudioOutputOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentOutputCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentOutputAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readCurrentOutputAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentOutputCommandParams + ); + result.put("readCurrentOutputAttribute", readAudioOutputCurrentOutputAttributeInteractionInfo); + Map readAudioOutputGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.AudioOutputCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterGeneratedCommandListAttributeCallback(), + readAudioOutputGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readAudioOutputGeneratedCommandListAttributeInteractionInfo); + Map readAudioOutputAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.AudioOutputCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAcceptedCommandListAttributeCallback(), + readAudioOutputAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readAudioOutputAcceptedCommandListAttributeInteractionInfo); + Map readAudioOutputEventListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readEventListAttribute( + (ChipClusters.AudioOutputCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterEventListAttributeCallback(), + readAudioOutputEventListCommandParams + ); + result.put("readEventListAttribute", readAudioOutputEventListAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( + (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAudioOutputFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readAudioOutputFeatureMapAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readApplicationLauncherInteractionInfo() { + Map result = new LinkedHashMap<>();Map readApplicationLauncherCatalogListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherCatalogListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readCatalogListAttribute( + (ChipClusters.ApplicationLauncherCluster.CatalogListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterCatalogListAttributeCallback(), + readApplicationLauncherCatalogListCommandParams + ); + result.put("readCatalogListAttribute", readApplicationLauncherCatalogListAttributeInteractionInfo); + Map readApplicationLauncherGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ApplicationLauncherCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterGeneratedCommandListAttributeCallback(), + readApplicationLauncherGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readApplicationLauncherGeneratedCommandListAttributeInteractionInfo); + Map readApplicationLauncherAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ApplicationLauncherCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAcceptedCommandListAttributeCallback(), + readApplicationLauncherAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readApplicationLauncherAcceptedCommandListAttributeInteractionInfo); + Map readApplicationLauncherEventListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readEventListAttribute( + (ChipClusters.ApplicationLauncherCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterEventListAttributeCallback(), + readApplicationLauncherEventListCommandParams + ); + result.put("readEventListAttribute", readApplicationLauncherEventListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( + (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readApplicationLauncherFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readApplicationLauncherFeatureMapAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readApplicationBasicInteractionInfo() { + Map result = new LinkedHashMap<>();Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readApplicationBasicVendorNameCommandParams + ); + result.put("readVendorNameAttribute", readApplicationBasicVendorNameAttributeInteractionInfo); + Map readApplicationBasicVendorIDCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readVendorIDAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicVendorIDCommandParams + ); + result.put("readVendorIDAttribute", readApplicationBasicVendorIDAttributeInteractionInfo); + Map readApplicationBasicApplicationNameCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readApplicationBasicApplicationNameCommandParams + ); + result.put("readApplicationNameAttribute", readApplicationBasicApplicationNameAttributeInteractionInfo); + Map readApplicationBasicProductIDCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicProductIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readProductIDAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicProductIDCommandParams + ); + result.put("readProductIDAttribute", readApplicationBasicProductIDAttributeInteractionInfo); + Map readApplicationBasicStatusCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicStatusCommandParams + ); + result.put("readStatusAttribute", readApplicationBasicStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readApplicationBasicApplicationVersionCommandParams + ); + result.put("readApplicationVersionAttribute", readApplicationBasicApplicationVersionAttributeInteractionInfo); + Map readApplicationBasicAllowedVendorListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicAllowedVendorListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readAllowedVendorListAttribute( + (ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback(), + readApplicationBasicAllowedVendorListCommandParams + ); + result.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ApplicationBasicCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterGeneratedCommandListAttributeCallback(), + readApplicationBasicGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readApplicationBasicGeneratedCommandListAttributeInteractionInfo); + Map readApplicationBasicAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ApplicationBasicCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAcceptedCommandListAttributeCallback(), + readApplicationBasicAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readApplicationBasicAcceptedCommandListAttributeInteractionInfo); + Map readApplicationBasicEventListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readEventListAttribute( + (ChipClusters.ApplicationBasicCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterEventListAttributeCallback(), + readApplicationBasicEventListCommandParams + ); + result.put("readEventListAttribute", readApplicationBasicEventListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( + (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readApplicationBasicFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readApplicationBasicFeatureMapAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readAccountLoginInteractionInfo() { + Map result = new LinkedHashMap<>();Map readAccountLoginGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.AccountLoginCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterGeneratedCommandListAttributeCallback(), + readAccountLoginGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readAccountLoginGeneratedCommandListAttributeInteractionInfo); + Map readAccountLoginAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.AccountLoginCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAcceptedCommandListAttributeCallback(), + readAccountLoginAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readAccountLoginAcceptedCommandListAttributeInteractionInfo); + Map readAccountLoginEventListCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readEventListAttribute( + (ChipClusters.AccountLoginCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterEventListAttributeCallback(), + readAccountLoginEventListCommandParams + ); + result.put("readEventListAttribute", readAccountLoginEventListAttributeInteractionInfo); + Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( + (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAccountLoginFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readAccountLoginFeatureMapAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readElectricalMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>();Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementMeasurementTypeCommandParams + ); + result.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageCommandParams + ); + result.put("readDcVoltageAttribute", readElectricalMeasurementDcVoltageAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageMinCommandParams + ); + result.put("readDcVoltageMinAttribute", readElectricalMeasurementDcVoltageMinAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageMaxCommandParams + ); + result.put("readDcVoltageMaxAttribute", readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentCommandParams + ); + result.put("readDcCurrentAttribute", readElectricalMeasurementDcCurrentAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentMinCommandParams + ); + result.put("readDcCurrentMinAttribute", readElectricalMeasurementDcCurrentMinAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentMaxCommandParams + ); + result.put("readDcCurrentMaxAttribute", readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerCommandParams + ); + result.put("readDcPowerAttribute", readElectricalMeasurementDcPowerAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerMinCommandParams + ); + result.put("readDcPowerMinAttribute", readElectricalMeasurementDcPowerMinAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerMaxCommandParams + ); + result.put("readDcPowerMaxAttribute", readElectricalMeasurementDcPowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageMultiplierCommandParams + ); + result.put("readDcVoltageMultiplierAttribute", readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageDivisorCommandParams + ); + result.put("readDcVoltageDivisorAttribute", readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentMultiplierCommandParams + ); + result.put("readDcCurrentMultiplierAttribute", readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentDivisorCommandParams + ); + result.put("readDcCurrentDivisorAttribute", readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerMultiplierCommandParams + ); + result.put("readDcPowerMultiplierAttribute", readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerDivisorCommandParams + ); + result.put("readDcPowerDivisorAttribute", readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyCommandParams + ); + result.put("readAcFrequencyAttribute", readElectricalMeasurementAcFrequencyAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyMinCommandParams + ); + result.put("readAcFrequencyMinAttribute", readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyMaxCommandParams + ); + result.put("readAcFrequencyMaxAttribute", readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo); + Map readElectricalMeasurementNeutralCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementNeutralCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readNeutralCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementNeutralCurrentCommandParams + ); + result.put("readNeutralCurrentAttribute", readElectricalMeasurementNeutralCurrentAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementTotalActivePowerCommandParams + ); + result.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementTotalReactivePowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalReactivePowerAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementTotalReactivePowerCommandParams + ); + result.put("readTotalReactivePowerAttribute", readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo); + Map readElectricalMeasurementTotalApparentPowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalApparentPowerAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementTotalApparentPowerCommandParams + ); + result.put("readTotalApparentPowerAttribute", readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo); + Map readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured1stHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams + ); + result.put("readMeasured1stHarmonicCurrentAttribute", readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured3rdHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams + ); + result.put("readMeasured3rdHarmonicCurrentAttribute", readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured5thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams + ); + result.put("readMeasured5thHarmonicCurrentAttribute", readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured7thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams + ); + result.put("readMeasured7thHarmonicCurrentAttribute", readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured9thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams + ); + result.put("readMeasured9thHarmonicCurrentAttribute", readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured11thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams + ); + result.put("readMeasured11thHarmonicCurrentAttribute", readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase1stHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams + ); + result.put("readMeasuredPhase1stHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase3rdHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams + ); + result.put("readMeasuredPhase3rdHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase5thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams + ); + result.put("readMeasuredPhase5thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase7thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams + ); + result.put("readMeasuredPhase7thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase9thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams + ); + result.put("readMeasuredPhase9thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase11thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams + ); + result.put("readMeasuredPhase11thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyMultiplierCommandParams + ); + result.put("readAcFrequencyMultiplierAttribute", readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyDivisorCommandParams + ); + result.put("readAcFrequencyDivisorAttribute", readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo); + Map readElectricalMeasurementPowerMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerMultiplierAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementPowerMultiplierCommandParams + ); + result.put("readPowerMultiplierAttribute", readElectricalMeasurementPowerMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementPowerDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerDivisorAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementPowerDivisorCommandParams + ); + result.put("readPowerDivisorAttribute", readElectricalMeasurementPowerDivisorAttributeInteractionInfo); + Map readElectricalMeasurementHarmonicCurrentMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readHarmonicCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementHarmonicCurrentMultiplierCommandParams + ); + result.put("readHarmonicCurrentMultiplierAttribute", readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readPhaseHarmonicCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams + ); + result.put("readPhaseHarmonicCurrentMultiplierAttribute", readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousVoltageCommandParams + ); + result.put("readInstantaneousVoltageAttribute", readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousLineCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousLineCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousLineCurrentCommandParams + ); + result.put("readInstantaneousLineCurrentAttribute", readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousActiveCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousActiveCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousActiveCurrentCommandParams + ); + result.put("readInstantaneousActiveCurrentAttribute", readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousReactiveCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousReactiveCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousReactiveCurrentCommandParams + ); + result.put("readInstantaneousReactiveCurrentAttribute", readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousPowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousPowerAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousPowerCommandParams + ); + result.put("readInstantaneousPowerAttribute", readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams + ); + result.put("readRmsVoltageAttribute", readElectricalMeasurementRmsVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMinCommandParams + ); + result.put("readRmsVoltageMinAttribute", readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMaxCommandParams + ); + result.put("readRmsVoltageMaxAttribute", readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentCommandParams + ); + result.put("readRmsCurrentAttribute", readElectricalMeasurementRmsCurrentAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMinCommandParams + ); + result.put("readRmsCurrentMinAttribute", readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMaxCommandParams + ); + result.put("readRmsCurrentMaxAttribute", readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerCommandParams + ); + result.put("readActivePowerAttribute", readElectricalMeasurementActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMinCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMinCommandParams + ); + result.put("readActivePowerMinAttribute", readElectricalMeasurementActivePowerMinAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMaxCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMaxCommandParams + ); + result.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementReactivePowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactivePowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactivePowerAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactivePowerCommandParams + ); + result.put("readReactivePowerAttribute", readElectricalMeasurementReactivePowerAttributeInteractionInfo); + Map readElectricalMeasurementApparentPowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementApparentPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readApparentPowerAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementApparentPowerCommandParams + ); + result.put("readApparentPowerAttribute", readElectricalMeasurementApparentPowerAttributeInteractionInfo); + Map readElectricalMeasurementPowerFactorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerFactorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerFactorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPowerFactorCommandParams + ); + result.put("readPowerFactorAttribute", readElectricalMeasurementPowerFactorAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsVoltageMeasurementPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams + ); + result.put("readAverageRmsVoltageMeasurementPeriodAttribute", readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageCounterAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams + ); + result.put("readAverageRmsUnderVoltageCounterAttribute", readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltagePeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams + ); + result.put("readRmsExtremeOverVoltagePeriodAttribute", readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltagePeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams + ); + result.put("readRmsExtremeUnderVoltagePeriodAttribute", readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSagPeriodCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagPeriodCommandParams + ); + result.put("readRmsVoltageSagPeriodAttribute", readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSwellPeriodCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellPeriodCommandParams + ); + result.put("readRmsVoltageSwellPeriodAttribute", readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); + Map readElectricalMeasurementAcVoltageMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcVoltageMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcVoltageMultiplierCommandParams + ); + result.put("readAcVoltageMultiplierAttribute", readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcVoltageDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcVoltageDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcVoltageDivisorCommandParams + ); + result.put("readAcVoltageDivisorAttribute", readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo); + Map readElectricalMeasurementAcCurrentMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcCurrentMultiplierCommandParams + ); + result.put("readAcCurrentMultiplierAttribute", readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcCurrentDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcCurrentDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcCurrentDivisorCommandParams + ); + result.put("readAcCurrentDivisorAttribute", readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo); + Map readElectricalMeasurementAcPowerMultiplierCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcPowerMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcPowerMultiplierCommandParams + ); + result.put("readAcPowerMultiplierAttribute", readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcPowerDivisorCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcPowerDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcPowerDivisorCommandParams + ); + result.put("readAcPowerDivisorAttribute", readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo); + Map readElectricalMeasurementOverloadAlarmsMaskCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readOverloadAlarmsMaskAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementOverloadAlarmsMaskCommandParams + ); + result.put("readOverloadAlarmsMaskAttribute", readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); + Map readElectricalMeasurementVoltageOverloadCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementVoltageOverloadAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readVoltageOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementVoltageOverloadCommandParams + ); + result.put("readVoltageOverloadAttribute", readElectricalMeasurementVoltageOverloadAttributeInteractionInfo); + Map readElectricalMeasurementCurrentOverloadCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementCurrentOverloadAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readCurrentOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementCurrentOverloadCommandParams + ); + result.put("readCurrentOverloadAttribute", readElectricalMeasurementCurrentOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcOverloadAlarmsMaskCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcOverloadAlarmsMaskAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcOverloadAlarmsMaskCommandParams + ); + result.put("readAcOverloadAlarmsMaskAttribute", readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); + Map readElectricalMeasurementAcVoltageOverloadCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcVoltageOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcVoltageOverloadCommandParams + ); + result.put("readAcVoltageOverloadAttribute", readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcCurrentOverloadCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcCurrentOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcCurrentOverloadCommandParams + ); + result.put("readAcCurrentOverloadAttribute", readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcActivePowerOverloadCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcActivePowerOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcActivePowerOverloadCommandParams + ); + result.put("readAcActivePowerOverloadAttribute", readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcReactivePowerOverloadCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcReactivePowerOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcReactivePowerOverloadCommandParams + ); + result.put("readAcReactivePowerOverloadAttribute", readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsOverVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsOverVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsOverVoltageCommandParams + ); + result.put("readAverageRmsOverVoltageAttribute", readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsUnderVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCommandParams + ); + result.put("readAverageRmsUnderVoltageAttribute", readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeOverVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltageCommandParams + ); + result.put("readRmsExtremeOverVoltageAttribute", readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeUnderVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltageCommandParams + ); + result.put("readRmsExtremeUnderVoltageAttribute", readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSagCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagCommandParams + ); + result.put("readRmsVoltageSagAttribute", readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSwellCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellCommandParams + ); + result.put("readRmsVoltageSwellAttribute", readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo); + Map readElectricalMeasurementLineCurrentPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readLineCurrentPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementLineCurrentPhaseBCommandParams + ); + result.put("readLineCurrentPhaseBAttribute", readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActiveCurrentPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActiveCurrentPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActiveCurrentPhaseBCommandParams + ); + result.put("readActiveCurrentPhaseBAttribute", readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementReactiveCurrentPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactiveCurrentPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactiveCurrentPhaseBCommandParams + ); + result.put("readReactiveCurrentPhaseBAttribute", readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltagePhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltagePhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltagePhaseBCommandParams + ); + result.put("readRmsVoltagePhaseBAttribute", readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMinPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMinPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMinPhaseBCommandParams + ); + result.put("readRmsVoltageMinPhaseBAttribute", readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMaxPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams + ); + result.put("readRmsVoltageMaxPhaseBAttribute", readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentPhaseBCommandParams + ); + result.put("readRmsCurrentPhaseBAttribute", readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMinPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMinPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMinPhaseBCommandParams + ); + result.put("readRmsCurrentMinPhaseBAttribute", readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMaxPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams + ); + result.put("readRmsCurrentMaxPhaseBAttribute", readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerPhaseBCommandParams + ); + result.put("readActivePowerPhaseBAttribute", readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMinPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMinPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMinPhaseBCommandParams + ); + result.put("readActivePowerMinPhaseBAttribute", readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMaxPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMaxPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMaxPhaseBCommandParams + ); + result.put("readActivePowerMaxPhaseBAttribute", readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementReactivePowerPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactivePowerPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactivePowerPhaseBCommandParams + ); + result.put("readReactivePowerPhaseBAttribute", readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementApparentPowerPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readApparentPowerPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementApparentPowerPhaseBCommandParams + ); + result.put("readApparentPowerPhaseBAttribute", readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementPowerFactorPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerFactorPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPowerFactorPhaseBCommandParams + ); + result.put("readPowerFactorPhaseBAttribute", readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsVoltageMeasurementPeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams + ); + result.put("readAverageRmsVoltageMeasurementPeriodPhaseBAttribute", readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsOverVoltageCounterPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams + ); + result.put("readAverageRmsOverVoltageCounterPhaseBAttribute", readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageCounterPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams + ); + result.put("readAverageRmsUnderVoltageCounterPhaseBAttribute", readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltagePeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams + ); + result.put("readRmsExtremeOverVoltagePeriodPhaseBAttribute", readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltagePeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams + ); + result.put("readRmsExtremeUnderVoltagePeriodPhaseBAttribute", readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagPeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams + ); + result.put("readRmsVoltageSagPeriodPhaseBAttribute", readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellPeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams + ); + result.put("readRmsVoltageSwellPeriodPhaseBAttribute", readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementLineCurrentPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readLineCurrentPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementLineCurrentPhaseCCommandParams + ); + result.put("readLineCurrentPhaseCAttribute", readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActiveCurrentPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActiveCurrentPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActiveCurrentPhaseCCommandParams + ); + result.put("readActiveCurrentPhaseCAttribute", readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementReactiveCurrentPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactiveCurrentPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactiveCurrentPhaseCCommandParams + ); + result.put("readReactiveCurrentPhaseCAttribute", readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltagePhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltagePhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltagePhaseCCommandParams + ); + result.put("readRmsVoltagePhaseCAttribute", readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMinPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMinPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMinPhaseCCommandParams + ); + result.put("readRmsVoltageMinPhaseCAttribute", readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMaxPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams + ); + result.put("readRmsVoltageMaxPhaseCAttribute", readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentPhaseCCommandParams + ); + result.put("readRmsCurrentPhaseCAttribute", readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMinPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMinPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMinPhaseCCommandParams + ); + result.put("readRmsCurrentMinPhaseCAttribute", readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMaxPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams + ); + result.put("readRmsCurrentMaxPhaseCAttribute", readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerPhaseCCommandParams + ); + result.put("readActivePowerPhaseCAttribute", readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMinPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMinPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMinPhaseCCommandParams + ); + result.put("readActivePowerMinPhaseCAttribute", readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMaxPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMaxPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMaxPhaseCCommandParams + ); + result.put("readActivePowerMaxPhaseCAttribute", readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementReactivePowerPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactivePowerPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactivePowerPhaseCCommandParams + ); + result.put("readReactivePowerPhaseCAttribute", readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementApparentPowerPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readApparentPowerPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementApparentPowerPhaseCCommandParams + ); + result.put("readApparentPowerPhaseCAttribute", readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementPowerFactorPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerFactorPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPowerFactorPhaseCCommandParams + ); + result.put("readPowerFactorPhaseCAttribute", readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsVoltageMeasurementPeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams + ); + result.put("readAverageRmsVoltageMeasurementPeriodPhaseCAttribute", readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsOverVoltageCounterPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams + ); + result.put("readAverageRmsOverVoltageCounterPhaseCAttribute", readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageCounterPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams + ); + result.put("readAverageRmsUnderVoltageCounterPhaseCAttribute", readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltagePeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams + ); + result.put("readRmsExtremeOverVoltagePeriodPhaseCAttribute", readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltagePeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams + ); + result.put("readRmsExtremeUnderVoltagePeriodPhaseCAttribute", readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagPeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams + ); + result.put("readRmsVoltageSagPeriodPhaseCAttribute", readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellPeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams + ); + result.put("readRmsVoltageSwellPeriodPhaseCAttribute", readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.ElectricalMeasurementCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterGeneratedCommandListAttributeCallback(), + readElectricalMeasurementGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readElectricalMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.ElectricalMeasurementCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAcceptedCommandListAttributeCallback(), + readElectricalMeasurementAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readElectricalMeasurementEventListCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readEventListAttribute( + (ChipClusters.ElectricalMeasurementCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterEventListAttributeCallback(), + readElectricalMeasurementEventListCommandParams + ); + result.put("readEventListAttribute", readElectricalMeasurementEventListAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( + (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readElectricalMeasurementFeatureMapAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readUnitTestingInteractionInfo() { + Map result = new LinkedHashMap<>();Map readUnitTestingBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingBooleanCommandParams + ); + result.put("readBooleanAttribute", readUnitTestingBooleanAttributeInteractionInfo); + Map readUnitTestingBitmap8CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readBitmap8Attribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingBitmap8CommandParams + ); + result.put("readBitmap8Attribute", readUnitTestingBitmap8AttributeInteractionInfo); + Map readUnitTestingBitmap16CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readBitmap16Attribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingBitmap16CommandParams + ); + result.put("readBitmap16Attribute", readUnitTestingBitmap16AttributeInteractionInfo); + Map readUnitTestingBitmap32CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readBitmap32Attribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingBitmap32CommandParams + ); + result.put("readBitmap32Attribute", readUnitTestingBitmap32AttributeInteractionInfo); + Map readUnitTestingBitmap64CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readBitmap64Attribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingBitmap64CommandParams + ); + result.put("readBitmap64Attribute", readUnitTestingBitmap64AttributeInteractionInfo); + Map readUnitTestingInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt8uCommandParams + ); + result.put("readInt8uAttribute", readUnitTestingInt8uAttributeInteractionInfo); + Map readUnitTestingInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt16uCommandParams + ); + result.put("readInt16uAttribute", readUnitTestingInt16uAttributeInteractionInfo); + Map readUnitTestingInt24uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt24uAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt24uCommandParams + ); + result.put("readInt24uAttribute", readUnitTestingInt24uAttributeInteractionInfo); + Map readUnitTestingInt32uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt32uAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt32uCommandParams + ); + result.put("readInt32uAttribute", readUnitTestingInt32uAttributeInteractionInfo); + Map readUnitTestingInt40uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt40uAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt40uCommandParams + ); + result.put("readInt40uAttribute", readUnitTestingInt40uAttributeInteractionInfo); + Map readUnitTestingInt48uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt48uAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt48uCommandParams + ); + result.put("readInt48uAttribute", readUnitTestingInt48uAttributeInteractionInfo); + Map readUnitTestingInt56uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt56uAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt56uCommandParams + ); + result.put("readInt56uAttribute", readUnitTestingInt56uAttributeInteractionInfo); + Map readUnitTestingInt64uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt64uAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt64uCommandParams + ); + result.put("readInt64uAttribute", readUnitTestingInt64uAttributeInteractionInfo); + Map readUnitTestingInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt8sCommandParams + ); + result.put("readInt8sAttribute", readUnitTestingInt8sAttributeInteractionInfo); + Map readUnitTestingInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt16sCommandParams + ); + result.put("readInt16sAttribute", readUnitTestingInt16sAttributeInteractionInfo); + Map readUnitTestingInt24sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt24sAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt24sCommandParams + ); + result.put("readInt24sAttribute", readUnitTestingInt24sAttributeInteractionInfo); + Map readUnitTestingInt32sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt32sAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt32sCommandParams + ); + result.put("readInt32sAttribute", readUnitTestingInt32sAttributeInteractionInfo); + Map readUnitTestingInt40sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt40sAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt40sCommandParams + ); + result.put("readInt40sAttribute", readUnitTestingInt40sAttributeInteractionInfo); + Map readUnitTestingInt48sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt48sAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt48sCommandParams + ); + result.put("readInt48sAttribute", readUnitTestingInt48sAttributeInteractionInfo); + Map readUnitTestingInt56sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt56sAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt56sCommandParams + ); + result.put("readInt56sAttribute", readUnitTestingInt56sAttributeInteractionInfo); + Map readUnitTestingInt64sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readInt64sAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt64sCommandParams + ); + result.put("readInt64sAttribute", readUnitTestingInt64sAttributeInteractionInfo); + Map readUnitTestingEnum8CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readEnum8Attribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingEnum8CommandParams + ); + result.put("readEnum8Attribute", readUnitTestingEnum8AttributeInteractionInfo); + Map readUnitTestingEnum16CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readEnum16Attribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingEnum16CommandParams + ); + result.put("readEnum16Attribute", readUnitTestingEnum16AttributeInteractionInfo); + Map readUnitTestingFloatSingleCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readFloatSingleAttribute( + (ChipClusters.FloatAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readUnitTestingFloatSingleCommandParams + ); + result.put("readFloatSingleAttribute", readUnitTestingFloatSingleAttributeInteractionInfo); + Map readUnitTestingFloatDoubleCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readFloatDoubleAttribute( + (ChipClusters.DoubleAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), + readUnitTestingFloatDoubleCommandParams + ); + result.put("readFloatDoubleAttribute", readUnitTestingFloatDoubleAttributeInteractionInfo); + Map readUnitTestingOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readOctetStringAttribute( + (ChipClusters.OctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), + readUnitTestingOctetStringCommandParams + ); + result.put("readOctetStringAttribute", readUnitTestingOctetStringAttributeInteractionInfo); + Map readUnitTestingListInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingListInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readListInt8uAttribute( + (ChipClusters.UnitTestingCluster.ListInt8uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListInt8uAttributeCallback(), + readUnitTestingListInt8uCommandParams + ); + result.put("readListInt8uAttribute", readUnitTestingListInt8uAttributeInteractionInfo); + Map readUnitTestingListOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingListOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readListOctetStringAttribute( + (ChipClusters.UnitTestingCluster.ListOctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListOctetStringAttributeCallback(), + readUnitTestingListOctetStringCommandParams + ); + result.put("readListOctetStringAttribute", readUnitTestingListOctetStringAttributeInteractionInfo); + Map readUnitTestingListStructOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingListStructOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readListStructOctetStringAttribute( + (ChipClusters.UnitTestingCluster.ListStructOctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListStructOctetStringAttributeCallback(), + readUnitTestingListStructOctetStringCommandParams + ); + result.put("readListStructOctetStringAttribute", readUnitTestingListStructOctetStringAttributeInteractionInfo); + Map readUnitTestingLongOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readLongOctetStringAttribute( + (ChipClusters.OctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), + readUnitTestingLongOctetStringCommandParams + ); + result.put("readLongOctetStringAttribute", readUnitTestingLongOctetStringAttributeInteractionInfo); + Map readUnitTestingCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readCharStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readUnitTestingCharStringCommandParams + ); + result.put("readCharStringAttribute", readUnitTestingCharStringAttributeInteractionInfo); + Map readUnitTestingLongCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingLongCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readLongCharStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readUnitTestingLongCharStringCommandParams + ); + result.put("readLongCharStringAttribute", readUnitTestingLongCharStringAttributeInteractionInfo); + Map readUnitTestingEpochUsCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingEpochUsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readEpochUsAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingEpochUsCommandParams + ); + result.put("readEpochUsAttribute", readUnitTestingEpochUsAttributeInteractionInfo); + Map readUnitTestingEpochSCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingEpochSAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readEpochSAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingEpochSCommandParams + ); + result.put("readEpochSAttribute", readUnitTestingEpochSAttributeInteractionInfo); + Map readUnitTestingVendorIdCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readVendorIdAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingVendorIdCommandParams + ); + result.put("readVendorIdAttribute", readUnitTestingVendorIdAttributeInteractionInfo); + Map readUnitTestingListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readListNullablesAndOptionalsStructAttribute( + (ChipClusters.UnitTestingCluster.ListNullablesAndOptionalsStructAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListNullablesAndOptionalsStructAttributeCallback(), + readUnitTestingListNullablesAndOptionalsStructCommandParams + ); + result.put("readListNullablesAndOptionalsStructAttribute", readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readUnitTestingEnumAttrCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readEnumAttrAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingEnumAttrCommandParams + ); + result.put("readEnumAttrAttribute", readUnitTestingEnumAttrAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt8uCommandParams + ); + result.put("readRangeRestrictedInt8uAttribute", readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt8sCommandParams + ); + result.put("readRangeRestrictedInt8sAttribute", readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt16uCommandParams + ); + result.put("readRangeRestrictedInt16uAttribute", readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt16sCommandParams + ); + result.put("readRangeRestrictedInt16sAttribute", readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); + Map readUnitTestingListLongOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingListLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readListLongOctetStringAttribute( + (ChipClusters.UnitTestingCluster.ListLongOctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListLongOctetStringAttributeCallback(), + readUnitTestingListLongOctetStringCommandParams + ); + result.put("readListLongOctetStringAttribute", readUnitTestingListLongOctetStringAttributeInteractionInfo); + Map readUnitTestingListFabricScopedCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingListFabricScopedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readListFabricScopedAttribute( + (ChipClusters.UnitTestingCluster.ListFabricScopedAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListFabricScopedAttributeCallback(), + readUnitTestingListFabricScopedCommandParams + ); + result.put("readListFabricScopedAttribute", readUnitTestingListFabricScopedAttributeInteractionInfo); + Map readUnitTestingTimedWriteBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readTimedWriteBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingTimedWriteBooleanCommandParams + ); + result.put("readTimedWriteBooleanAttribute", readUnitTestingTimedWriteBooleanAttributeInteractionInfo); + Map readUnitTestingGeneralErrorBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readGeneralErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingGeneralErrorBooleanCommandParams + ); + result.put("readGeneralErrorBooleanAttribute", readUnitTestingGeneralErrorBooleanAttributeInteractionInfo); + Map readUnitTestingClusterErrorBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readClusterErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingClusterErrorBooleanCommandParams + ); + result.put("readClusterErrorBooleanAttribute", readUnitTestingClusterErrorBooleanAttributeInteractionInfo); + Map readUnitTestingUnsupportedCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingUnsupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readUnsupportedAttribute( + (ChipClusters.BooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingUnsupportedCommandParams + ); + result.put("readUnsupportedAttribute", readUnitTestingUnsupportedAttributeInteractionInfo); + Map readUnitTestingNullableBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableBooleanAttribute( + (ChipClusters.UnitTestingCluster.NullableBooleanAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBooleanAttributeCallback(), + readUnitTestingNullableBooleanCommandParams + ); + result.put("readNullableBooleanAttribute", readUnitTestingNullableBooleanAttributeInteractionInfo); + Map readUnitTestingNullableBitmap8CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap8Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap8AttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap8AttributeCallback(), + readUnitTestingNullableBitmap8CommandParams + ); + result.put("readNullableBitmap8Attribute", readUnitTestingNullableBitmap8AttributeInteractionInfo); + Map readUnitTestingNullableBitmap16CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap16Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap16AttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap16AttributeCallback(), + readUnitTestingNullableBitmap16CommandParams + ); + result.put("readNullableBitmap16Attribute", readUnitTestingNullableBitmap16AttributeInteractionInfo); + Map readUnitTestingNullableBitmap32CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap32Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap32AttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap32AttributeCallback(), + readUnitTestingNullableBitmap32CommandParams + ); + result.put("readNullableBitmap32Attribute", readUnitTestingNullableBitmap32AttributeInteractionInfo); + Map readUnitTestingNullableBitmap64CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap64Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap64AttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap64AttributeCallback(), + readUnitTestingNullableBitmap64CommandParams + ); + result.put("readNullableBitmap64Attribute", readUnitTestingNullableBitmap64AttributeInteractionInfo); + Map readUnitTestingNullableInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt8uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt8uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8uAttributeCallback(), + readUnitTestingNullableInt8uCommandParams + ); + result.put("readNullableInt8uAttribute", readUnitTestingNullableInt8uAttributeInteractionInfo); + Map readUnitTestingNullableInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt16uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt16uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16uAttributeCallback(), + readUnitTestingNullableInt16uCommandParams + ); + result.put("readNullableInt16uAttribute", readUnitTestingNullableInt16uAttributeInteractionInfo); + Map readUnitTestingNullableInt24uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt24uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt24uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24uAttributeCallback(), + readUnitTestingNullableInt24uCommandParams + ); + result.put("readNullableInt24uAttribute", readUnitTestingNullableInt24uAttributeInteractionInfo); + Map readUnitTestingNullableInt32uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt32uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt32uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32uAttributeCallback(), + readUnitTestingNullableInt32uCommandParams + ); + result.put("readNullableInt32uAttribute", readUnitTestingNullableInt32uAttributeInteractionInfo); + Map readUnitTestingNullableInt40uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt40uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt40uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40uAttributeCallback(), + readUnitTestingNullableInt40uCommandParams + ); + result.put("readNullableInt40uAttribute", readUnitTestingNullableInt40uAttributeInteractionInfo); + Map readUnitTestingNullableInt48uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt48uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt48uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48uAttributeCallback(), + readUnitTestingNullableInt48uCommandParams + ); + result.put("readNullableInt48uAttribute", readUnitTestingNullableInt48uAttributeInteractionInfo); + Map readUnitTestingNullableInt56uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt56uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt56uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56uAttributeCallback(), + readUnitTestingNullableInt56uCommandParams + ); + result.put("readNullableInt56uAttribute", readUnitTestingNullableInt56uAttributeInteractionInfo); + Map readUnitTestingNullableInt64uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt64uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt64uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64uAttributeCallback(), + readUnitTestingNullableInt64uCommandParams + ); + result.put("readNullableInt64uAttribute", readUnitTestingNullableInt64uAttributeInteractionInfo); + Map readUnitTestingNullableInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt8sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt8sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8sAttributeCallback(), + readUnitTestingNullableInt8sCommandParams + ); + result.put("readNullableInt8sAttribute", readUnitTestingNullableInt8sAttributeInteractionInfo); + Map readUnitTestingNullableInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt16sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt16sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16sAttributeCallback(), + readUnitTestingNullableInt16sCommandParams + ); + result.put("readNullableInt16sAttribute", readUnitTestingNullableInt16sAttributeInteractionInfo); + Map readUnitTestingNullableInt24sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt24sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt24sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24sAttributeCallback(), + readUnitTestingNullableInt24sCommandParams + ); + result.put("readNullableInt24sAttribute", readUnitTestingNullableInt24sAttributeInteractionInfo); + Map readUnitTestingNullableInt32sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt32sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt32sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32sAttributeCallback(), + readUnitTestingNullableInt32sCommandParams + ); + result.put("readNullableInt32sAttribute", readUnitTestingNullableInt32sAttributeInteractionInfo); + Map readUnitTestingNullableInt40sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt40sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt40sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40sAttributeCallback(), + readUnitTestingNullableInt40sCommandParams + ); + result.put("readNullableInt40sAttribute", readUnitTestingNullableInt40sAttributeInteractionInfo); + Map readUnitTestingNullableInt48sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt48sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt48sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48sAttributeCallback(), + readUnitTestingNullableInt48sCommandParams + ); + result.put("readNullableInt48sAttribute", readUnitTestingNullableInt48sAttributeInteractionInfo); + Map readUnitTestingNullableInt56sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt56sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt56sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56sAttributeCallback(), + readUnitTestingNullableInt56sCommandParams + ); + result.put("readNullableInt56sAttribute", readUnitTestingNullableInt56sAttributeInteractionInfo); + Map readUnitTestingNullableInt64sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableInt64sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt64sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64sAttributeCallback(), + readUnitTestingNullableInt64sCommandParams + ); + result.put("readNullableInt64sAttribute", readUnitTestingNullableInt64sAttributeInteractionInfo); + Map readUnitTestingNullableEnum8CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableEnum8Attribute( + (ChipClusters.UnitTestingCluster.NullableEnum8AttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum8AttributeCallback(), + readUnitTestingNullableEnum8CommandParams + ); + result.put("readNullableEnum8Attribute", readUnitTestingNullableEnum8AttributeInteractionInfo); + Map readUnitTestingNullableEnum16CommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableEnum16Attribute( + (ChipClusters.UnitTestingCluster.NullableEnum16AttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum16AttributeCallback(), + readUnitTestingNullableEnum16CommandParams + ); + result.put("readNullableEnum16Attribute", readUnitTestingNullableEnum16AttributeInteractionInfo); + Map readUnitTestingNullableFloatSingleCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableFloatSingleAttribute( + (ChipClusters.UnitTestingCluster.NullableFloatSingleAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableFloatSingleAttributeCallback(), + readUnitTestingNullableFloatSingleCommandParams + ); + result.put("readNullableFloatSingleAttribute", readUnitTestingNullableFloatSingleAttributeInteractionInfo); + Map readUnitTestingNullableFloatDoubleCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableFloatDoubleAttribute( + (ChipClusters.UnitTestingCluster.NullableFloatDoubleAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableFloatDoubleAttributeCallback(), + readUnitTestingNullableFloatDoubleCommandParams + ); + result.put("readNullableFloatDoubleAttribute", readUnitTestingNullableFloatDoubleAttributeInteractionInfo); + Map readUnitTestingNullableOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableOctetStringAttribute( + (ChipClusters.UnitTestingCluster.NullableOctetStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableOctetStringAttributeCallback(), + readUnitTestingNullableOctetStringCommandParams + ); + result.put("readNullableOctetStringAttribute", readUnitTestingNullableOctetStringAttributeInteractionInfo); + Map readUnitTestingNullableCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableCharStringAttribute( + (ChipClusters.UnitTestingCluster.NullableCharStringAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableCharStringAttributeCallback(), + readUnitTestingNullableCharStringCommandParams + ); + result.put("readNullableCharStringAttribute", readUnitTestingNullableCharStringAttributeInteractionInfo); + Map readUnitTestingNullableEnumAttrCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableEnumAttrAttribute( + (ChipClusters.UnitTestingCluster.NullableEnumAttrAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnumAttrAttributeCallback(), + readUnitTestingNullableEnumAttrCommandParams + ); + result.put("readNullableEnumAttrAttribute", readUnitTestingNullableEnumAttrAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt8uAttribute( + (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt8uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt8uAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt8uCommandParams + ); + result.put("readNullableRangeRestrictedInt8uAttribute", readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt8sAttribute( + (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt8sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt8sAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt8sCommandParams + ); + result.put("readNullableRangeRestrictedInt8sAttribute", readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt16uAttribute( + (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt16uAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt16uAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt16uCommandParams + ); + result.put("readNullableRangeRestrictedInt16uAttribute", readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt16sAttribute( + (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt16sAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt16sAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt16sCommandParams + ); + result.put("readNullableRangeRestrictedInt16sAttribute", readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readUnitTestingWriteOnlyInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingWriteOnlyInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readWriteOnlyInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingWriteOnlyInt8uCommandParams + ); + result.put("readWriteOnlyInt8uAttribute", readUnitTestingWriteOnlyInt8uAttributeInteractionInfo); + Map readUnitTestingGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.UnitTestingCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterGeneratedCommandListAttributeCallback(), + readUnitTestingGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readUnitTestingGeneratedCommandListAttributeInteractionInfo); + Map readUnitTestingAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.UnitTestingCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterAcceptedCommandListAttributeCallback(), + readUnitTestingAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readUnitTestingAcceptedCommandListAttributeInteractionInfo); + Map readUnitTestingEventListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readEventListAttribute( + (ChipClusters.UnitTestingCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterEventListAttributeCallback(), + readUnitTestingEventListCommandParams + ); + result.put("readEventListAttribute", readUnitTestingEventListAttributeInteractionInfo); + Map readUnitTestingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readAttributeListAttribute( + (ChipClusters.UnitTestingCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterAttributeListAttributeCallback(), + readUnitTestingAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readUnitTestingAttributeListAttributeInteractionInfo); + Map readUnitTestingFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readUnitTestingFeatureMapAttributeInteractionInfo); + Map readUnitTestingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readUnitTestingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readUnitTestingClusterRevisionAttributeInteractionInfo); + + return result; + } + private static Map readFaultInjectionInteractionInfo() { + Map result = new LinkedHashMap<>();Map readFaultInjectionGeneratedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFaultInjectionGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster).readGeneratedCommandListAttribute( + (ChipClusters.FaultInjectionCluster.GeneratedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterGeneratedCommandListAttributeCallback(), + readFaultInjectionGeneratedCommandListCommandParams + ); + result.put("readGeneratedCommandListAttribute", readFaultInjectionGeneratedCommandListAttributeInteractionInfo); + Map readFaultInjectionAcceptedCommandListCommandParams = new LinkedHashMap(); + InteractionInfo readFaultInjectionAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster).readAcceptedCommandListAttribute( + (ChipClusters.FaultInjectionCluster.AcceptedCommandListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterAcceptedCommandListAttributeCallback(), + readFaultInjectionAcceptedCommandListCommandParams + ); + result.put("readAcceptedCommandListAttribute", readFaultInjectionAcceptedCommandListAttributeInteractionInfo); + Map readFaultInjectionEventListCommandParams = new LinkedHashMap(); + InteractionInfo readFaultInjectionEventListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster).readEventListAttribute( + (ChipClusters.FaultInjectionCluster.EventListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterEventListAttributeCallback(), + readFaultInjectionEventListCommandParams + ); + result.put("readEventListAttribute", readFaultInjectionEventListAttributeInteractionInfo); + Map readFaultInjectionAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFaultInjectionAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster).readAttributeListAttribute( + (ChipClusters.FaultInjectionCluster.AttributeListAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterAttributeListAttributeCallback(), + readFaultInjectionAttributeListCommandParams + ); + result.put("readAttributeListAttribute", readFaultInjectionAttributeListAttributeInteractionInfo); + Map readFaultInjectionFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readFaultInjectionFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster).readFeatureMapAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFaultInjectionFeatureMapCommandParams + ); + result.put("readFeatureMapAttribute", readFaultInjectionFeatureMapAttributeInteractionInfo); + Map readFaultInjectionClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFaultInjectionClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster).readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFaultInjectionClusterRevisionCommandParams + ); + result.put("readClusterRevisionAttribute", readFaultInjectionClusterRevisionAttributeInteractionInfo); + + return result; + } + @SuppressWarnings("serial") + public Map> getReadAttributeMap() { + + return new HashMap>(){{ + put("identify", readIdentifyInteractionInfo()); + put("groups", readGroupsInteractionInfo()); + put("scenes", readScenesInteractionInfo()); + put("onOff", readOnOffInteractionInfo()); + put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo()); + put("levelControl", readLevelControlInteractionInfo()); + put("binaryInputBasic", readBinaryInputBasicInteractionInfo()); + put("pulseWidthModulation", readPulseWidthModulationInteractionInfo()); + put("descriptor", readDescriptorInteractionInfo()); + put("binding", readBindingInteractionInfo()); + put("accessControl", readAccessControlInteractionInfo()); + put("actions", readActionsInteractionInfo()); + put("basicInformation", readBasicInformationInteractionInfo()); + put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo()); + put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo()); + put("localizationConfiguration", readLocalizationConfigurationInteractionInfo()); + put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo()); + put("unitLocalization", readUnitLocalizationInteractionInfo()); + put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo()); + put("powerSource", readPowerSourceInteractionInfo()); + put("generalCommissioning", readGeneralCommissioningInteractionInfo()); + put("networkCommissioning", readNetworkCommissioningInteractionInfo()); + put("diagnosticLogs", readDiagnosticLogsInteractionInfo()); + put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo()); + put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo()); + put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo()); + put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo()); + put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo()); + put("timeSynchronization", readTimeSynchronizationInteractionInfo()); + put("bridgedDeviceBasicInformation", readBridgedDeviceBasicInformationInteractionInfo()); + put("switch", readSwitchInteractionInfo()); + put("administratorCommissioning", readAdministratorCommissioningInteractionInfo()); + put("operationalCredentials", readOperationalCredentialsInteractionInfo()); + put("groupKeyManagement", readGroupKeyManagementInteractionInfo()); + put("fixedLabel", readFixedLabelInteractionInfo()); + put("userLabel", readUserLabelInteractionInfo()); + put("proxyConfiguration", readProxyConfigurationInteractionInfo()); + put("proxyDiscovery", readProxyDiscoveryInteractionInfo()); + put("proxyValid", readProxyValidInteractionInfo()); + put("booleanState", readBooleanStateInteractionInfo()); + put("icdManagement", readIcdManagementInteractionInfo()); + put("modeSelect", readModeSelectInteractionInfo()); + put("temperatureControl", readTemperatureControlInteractionInfo()); + put("refrigeratorAlarm", readRefrigeratorAlarmInteractionInfo()); + put("airQuality", readAirQualityInteractionInfo()); + put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo()); + put("dishwasherAlarm", readDishwasherAlarmInteractionInfo()); + put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo()); + put("activatedCarbonFilterMonitoring", readActivatedCarbonFilterMonitoringInteractionInfo()); + put("ceramicFilterMonitoring", readCeramicFilterMonitoringInteractionInfo()); + put("electrostaticFilterMonitoring", readElectrostaticFilterMonitoringInteractionInfo()); + put("uvFilterMonitoring", readUvFilterMonitoringInteractionInfo()); + put("ionizingFilterMonitoring", readIonizingFilterMonitoringInteractionInfo()); + put("zeoliteFilterMonitoring", readZeoliteFilterMonitoringInteractionInfo()); + put("ozoneFilterMonitoring", readOzoneFilterMonitoringInteractionInfo()); + put("waterTankMonitoring", readWaterTankMonitoringInteractionInfo()); + put("fuelTankMonitoring", readFuelTankMonitoringInteractionInfo()); + put("inkCartridgeMonitoring", readInkCartridgeMonitoringInteractionInfo()); + put("tonerCartridgeMonitoring", readTonerCartridgeMonitoringInteractionInfo()); + put("doorLock", readDoorLockInteractionInfo()); + put("windowCovering", readWindowCoveringInteractionInfo()); + put("barrierControl", readBarrierControlInteractionInfo()); + put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo()); + put("thermostat", readThermostatInteractionInfo()); + put("fanControl", readFanControlInteractionInfo()); + put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo()); + put("colorControl", readColorControlInteractionInfo()); + put("ballastConfiguration", readBallastConfigurationInteractionInfo()); + put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo()); + put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo()); + put("pressureMeasurement", readPressureMeasurementInteractionInfo()); + put("flowMeasurement", readFlowMeasurementInteractionInfo()); + put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo()); + put("occupancySensing", readOccupancySensingInteractionInfo()); + put("wakeOnLan", readWakeOnLanInteractionInfo()); + put("channel", readChannelInteractionInfo()); + put("targetNavigator", readTargetNavigatorInteractionInfo()); + put("mediaPlayback", readMediaPlaybackInteractionInfo()); + put("mediaInput", readMediaInputInteractionInfo()); + put("lowPower", readLowPowerInteractionInfo()); + put("keypadInput", readKeypadInputInteractionInfo()); + put("contentLauncher", readContentLauncherInteractionInfo()); + put("audioOutput", readAudioOutputInteractionInfo()); + put("applicationLauncher", readApplicationLauncherInteractionInfo()); + put("applicationBasic", readApplicationBasicInteractionInfo()); + put("accountLogin", readAccountLoginInteractionInfo()); + put("electricalMeasurement", readElectricalMeasurementInteractionInfo()); + put("unitTesting", readUnitTestingInteractionInfo()); + put("faultInjection", readFaultInjectionInteractionInfo());}}; + } } + diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index a5b3f16b622fd4..deaadbcc9e0a20 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -27,323 +27,414 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = - new LinkedHashMap(); + Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); CommandParameterInfo identifyidentifyTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeIdentifyIdentifyTimeCommandParams.put("value", identifyidentifyTimeCommandParameterInfo); - InteractionInfo writeIdentifyIdentifyTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .writeIdentifyTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeIdentifyIdentifyTimeCommandParams); - writeIdentifyInteractionInfo.put( - "writeIdentifyTimeAttribute", writeIdentifyIdentifyTimeAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeIdentifyIdentifyTimeCommandParams.put( + "value", + identifyidentifyTimeCommandParameterInfo + ); + InteractionInfo writeIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).writeIdentifyTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeIdentifyIdentifyTimeCommandParams + ); + writeIdentifyInteractionInfo.put("writeIdentifyTimeAttribute", writeIdentifyIdentifyTimeAttributeInteractionInfo); writeAttributeMap.put("identify", writeIdentifyInteractionInfo); Map writeGroupsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("groups", writeGroupsInteractionInfo); Map writeScenesInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("scenes", writeScenesInteractionInfo); Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = - new LinkedHashMap(); + Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); CommandParameterInfo onOffonTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeOnOffOnTimeCommandParams.put("value", onOffonTimeCommandParameterInfo); - InteractionInfo writeOnOffOnTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .writeOnTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffOnTimeCommandParams); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeOnOffOnTimeCommandParams.put( + "value", + onOffonTimeCommandParameterInfo + ); + InteractionInfo writeOnOffOnTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).writeOnTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffOnTimeCommandParams + ); writeOnOffInteractionInfo.put("writeOnTimeAttribute", writeOnOffOnTimeAttributeInteractionInfo); - Map writeOnOffOffWaitTimeCommandParams = - new LinkedHashMap(); + Map writeOnOffOffWaitTimeCommandParams = new LinkedHashMap(); CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeOnOffOffWaitTimeCommandParams.put("value", onOffoffWaitTimeCommandParameterInfo); - InteractionInfo writeOnOffOffWaitTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .writeOffWaitTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffOffWaitTimeCommandParams); - writeOnOffInteractionInfo.put( - "writeOffWaitTimeAttribute", writeOnOffOffWaitTimeAttributeInteractionInfo); - Map writeOnOffStartUpOnOffCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeOnOffOffWaitTimeCommandParams.put( + "value", + onOffoffWaitTimeCommandParameterInfo + ); + InteractionInfo writeOnOffOffWaitTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).writeOffWaitTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffOffWaitTimeCommandParams + ); + writeOnOffInteractionInfo.put("writeOffWaitTimeAttribute", writeOnOffOffWaitTimeAttributeInteractionInfo); + Map writeOnOffStartUpOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo onOffstartUpOnOffCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeOnOffStartUpOnOffCommandParams.put("value", onOffstartUpOnOffCommandParameterInfo); - InteractionInfo writeOnOffStartUpOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .writeStartUpOnOffAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffStartUpOnOffCommandParams); - writeOnOffInteractionInfo.put( - "writeStartUpOnOffAttribute", writeOnOffStartUpOnOffAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeOnOffStartUpOnOffCommandParams.put( + "value", + onOffstartUpOnOffCommandParameterInfo + ); + InteractionInfo writeOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).writeStartUpOnOffAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffStartUpOnOffCommandParams + ); + writeOnOffInteractionInfo.put("writeStartUpOnOffAttribute", writeOnOffStartUpOnOffAttributeInteractionInfo); writeAttributeMap.put("onOff", writeOnOffInteractionInfo); - Map writeOnOffSwitchConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map writeOnOffSwitchConfigurationSwitchActionsCommandParams = - new LinkedHashMap(); + Map writeOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeOnOffSwitchConfigurationSwitchActionsCommandParams = new LinkedHashMap(); CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOnOffSwitchConfigurationSwitchActionsCommandParams.put( - "value", onOffSwitchConfigurationswitchActionsCommandParameterInfo); - InteractionInfo writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .writeSwitchActionsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffSwitchConfigurationSwitchActionsCommandParams); - writeOnOffSwitchConfigurationInteractionInfo.put( - "writeSwitchActionsAttribute", - writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + "value", + onOffSwitchConfigurationswitchActionsCommandParameterInfo + ); + InteractionInfo writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).writeSwitchActionsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffSwitchConfigurationSwitchActionsCommandParams + ); + writeOnOffSwitchConfigurationInteractionInfo.put("writeSwitchActionsAttribute", writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = - new LinkedHashMap(); + Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); CommandParameterInfo levelControloptionsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeLevelControlOptionsCommandParams.put("value", levelControloptionsCommandParameterInfo); - InteractionInfo writeLevelControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeOptionsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOptionsCommandParams); - writeLevelControlInteractionInfo.put( - "writeOptionsAttribute", writeLevelControlOptionsAttributeInteractionInfo); - Map writeLevelControlOnOffTransitionTimeCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeLevelControlOptionsCommandParams.put( + "value", + levelControloptionsCommandParameterInfo + ); + InteractionInfo writeLevelControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeOptionsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOptionsCommandParams + ); + writeLevelControlInteractionInfo.put("writeOptionsAttribute", writeLevelControlOptionsAttributeInteractionInfo); + Map writeLevelControlOnOffTransitionTimeCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlonOffTransitionTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeLevelControlOnOffTransitionTimeCommandParams.put( - "value", levelControlonOffTransitionTimeCommandParameterInfo); - InteractionInfo writeLevelControlOnOffTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeOnOffTransitionTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOnOffTransitionTimeCommandParams); - writeLevelControlInteractionInfo.put( - "writeOnOffTransitionTimeAttribute", - writeLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map writeLevelControlOnLevelCommandParams = - new LinkedHashMap(); + "value", + levelControlonOffTransitionTimeCommandParameterInfo + ); + InteractionInfo writeLevelControlOnOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeOnOffTransitionTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOnOffTransitionTimeCommandParams + ); + writeLevelControlInteractionInfo.put("writeOnOffTransitionTimeAttribute", writeLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map writeLevelControlOnLevelCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlonLevelCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeLevelControlOnLevelCommandParams.put("value", levelControlonLevelCommandParameterInfo); - InteractionInfo writeLevelControlOnLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeOnLevelAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOnLevelCommandParams); - writeLevelControlInteractionInfo.put( - "writeOnLevelAttribute", writeLevelControlOnLevelAttributeInteractionInfo); - Map writeLevelControlOnTransitionTimeCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeLevelControlOnLevelCommandParams.put( + "value", + levelControlonLevelCommandParameterInfo + ); + InteractionInfo writeLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeOnLevelAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOnLevelCommandParams + ); + writeLevelControlInteractionInfo.put("writeOnLevelAttribute", writeLevelControlOnLevelAttributeInteractionInfo); + Map writeLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlonTransitionTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeLevelControlOnTransitionTimeCommandParams.put( - "value", levelControlonTransitionTimeCommandParameterInfo); - InteractionInfo writeLevelControlOnTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeOnTransitionTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOnTransitionTimeCommandParams); - writeLevelControlInteractionInfo.put( - "writeOnTransitionTimeAttribute", - writeLevelControlOnTransitionTimeAttributeInteractionInfo); - Map writeLevelControlOffTransitionTimeCommandParams = - new LinkedHashMap(); + "value", + levelControlonTransitionTimeCommandParameterInfo + ); + InteractionInfo writeLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeOnTransitionTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOnTransitionTimeCommandParams + ); + writeLevelControlInteractionInfo.put("writeOnTransitionTimeAttribute", writeLevelControlOnTransitionTimeAttributeInteractionInfo); + Map writeLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeLevelControlOffTransitionTimeCommandParams.put( - "value", levelControloffTransitionTimeCommandParameterInfo); - InteractionInfo writeLevelControlOffTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeOffTransitionTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOffTransitionTimeCommandParams); - writeLevelControlInteractionInfo.put( - "writeOffTransitionTimeAttribute", - writeLevelControlOffTransitionTimeAttributeInteractionInfo); - Map writeLevelControlDefaultMoveRateCommandParams = - new LinkedHashMap(); + "value", + levelControloffTransitionTimeCommandParameterInfo + ); + InteractionInfo writeLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeOffTransitionTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOffTransitionTimeCommandParams + ); + writeLevelControlInteractionInfo.put("writeOffTransitionTimeAttribute", writeLevelControlOffTransitionTimeAttributeInteractionInfo); + Map writeLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeLevelControlDefaultMoveRateCommandParams.put( - "value", levelControldefaultMoveRateCommandParameterInfo); - InteractionInfo writeLevelControlDefaultMoveRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeDefaultMoveRateAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlDefaultMoveRateCommandParams); - writeLevelControlInteractionInfo.put( - "writeDefaultMoveRateAttribute", writeLevelControlDefaultMoveRateAttributeInteractionInfo); - Map writeLevelControlStartUpCurrentLevelCommandParams = - new LinkedHashMap(); + "value", + levelControldefaultMoveRateCommandParameterInfo + ); + InteractionInfo writeLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeDefaultMoveRateAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlDefaultMoveRateCommandParams + ); + writeLevelControlInteractionInfo.put("writeDefaultMoveRateAttribute", writeLevelControlDefaultMoveRateAttributeInteractionInfo); + Map writeLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeLevelControlStartUpCurrentLevelCommandParams.put( - "value", levelControlstartUpCurrentLevelCommandParameterInfo); - InteractionInfo writeLevelControlStartUpCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .writeStartUpCurrentLevelAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlStartUpCurrentLevelCommandParams); - writeLevelControlInteractionInfo.put( - "writeStartUpCurrentLevelAttribute", - writeLevelControlStartUpCurrentLevelAttributeInteractionInfo); + "value", + levelControlstartUpCurrentLevelCommandParameterInfo + ); + InteractionInfo writeLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).writeStartUpCurrentLevelAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlStartUpCurrentLevelCommandParams + ); + writeLevelControlInteractionInfo.put("writeStartUpCurrentLevelAttribute", writeLevelControlStartUpCurrentLevelAttributeInteractionInfo); writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicActiveTextCommandParams = - new LinkedHashMap(); + Map writeBinaryInputBasicActiveTextCommandParams = new LinkedHashMap(); CommandParameterInfo binaryInputBasicactiveTextCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBinaryInputBasicActiveTextCommandParams.put( - "value", binaryInputBasicactiveTextCommandParameterInfo); - InteractionInfo writeBinaryInputBasicActiveTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .writeActiveTextAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicActiveTextCommandParams); - writeBinaryInputBasicInteractionInfo.put( - "writeActiveTextAttribute", writeBinaryInputBasicActiveTextAttributeInteractionInfo); - Map writeBinaryInputBasicDescriptionCommandParams = - new LinkedHashMap(); + "value", + binaryInputBasicactiveTextCommandParameterInfo + ); + InteractionInfo writeBinaryInputBasicActiveTextAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).writeActiveTextAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicActiveTextCommandParams + ); + writeBinaryInputBasicInteractionInfo.put("writeActiveTextAttribute", writeBinaryInputBasicActiveTextAttributeInteractionInfo); + Map writeBinaryInputBasicDescriptionCommandParams = new LinkedHashMap(); CommandParameterInfo binaryInputBasicdescriptionCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBinaryInputBasicDescriptionCommandParams.put( - "value", binaryInputBasicdescriptionCommandParameterInfo); - InteractionInfo writeBinaryInputBasicDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .writeDescriptionAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicDescriptionCommandParams); - writeBinaryInputBasicInteractionInfo.put( - "writeDescriptionAttribute", writeBinaryInputBasicDescriptionAttributeInteractionInfo); - Map writeBinaryInputBasicInactiveTextCommandParams = - new LinkedHashMap(); + "value", + binaryInputBasicdescriptionCommandParameterInfo + ); + InteractionInfo writeBinaryInputBasicDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).writeDescriptionAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicDescriptionCommandParams + ); + writeBinaryInputBasicInteractionInfo.put("writeDescriptionAttribute", writeBinaryInputBasicDescriptionAttributeInteractionInfo); + Map writeBinaryInputBasicInactiveTextCommandParams = new LinkedHashMap(); CommandParameterInfo binaryInputBasicinactiveTextCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBinaryInputBasicInactiveTextCommandParams.put( - "value", binaryInputBasicinactiveTextCommandParameterInfo); - InteractionInfo writeBinaryInputBasicInactiveTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .writeInactiveTextAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicInactiveTextCommandParams); - writeBinaryInputBasicInteractionInfo.put( - "writeInactiveTextAttribute", writeBinaryInputBasicInactiveTextAttributeInteractionInfo); - Map writeBinaryInputBasicOutOfServiceCommandParams = - new LinkedHashMap(); + "value", + binaryInputBasicinactiveTextCommandParameterInfo + ); + InteractionInfo writeBinaryInputBasicInactiveTextAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).writeInactiveTextAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicInactiveTextCommandParams + ); + writeBinaryInputBasicInteractionInfo.put("writeInactiveTextAttribute", writeBinaryInputBasicInactiveTextAttributeInteractionInfo); + Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeBinaryInputBasicOutOfServiceCommandParams.put( - "value", binaryInputBasicoutOfServiceCommandParameterInfo); - InteractionInfo writeBinaryInputBasicOutOfServiceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .writeOutOfServiceAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicOutOfServiceCommandParams); - writeBinaryInputBasicInteractionInfo.put( - "writeOutOfServiceAttribute", writeBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map writeBinaryInputBasicPresentValueCommandParams = - new LinkedHashMap(); + "value", + binaryInputBasicoutOfServiceCommandParameterInfo + ); + InteractionInfo writeBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).writeOutOfServiceAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicOutOfServiceCommandParams + ); + writeBinaryInputBasicInteractionInfo.put("writeOutOfServiceAttribute", writeBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map writeBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeBinaryInputBasicPresentValueCommandParams.put( - "value", binaryInputBasicpresentValueCommandParameterInfo); - InteractionInfo writeBinaryInputBasicPresentValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .writePresentValueAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicPresentValueCommandParams); - writeBinaryInputBasicInteractionInfo.put( - "writePresentValueAttribute", writeBinaryInputBasicPresentValueAttributeInteractionInfo); - Map writeBinaryInputBasicReliabilityCommandParams = - new LinkedHashMap(); + "value", + binaryInputBasicpresentValueCommandParameterInfo + ); + InteractionInfo writeBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).writePresentValueAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicPresentValueCommandParams + ); + writeBinaryInputBasicInteractionInfo.put("writePresentValueAttribute", writeBinaryInputBasicPresentValueAttributeInteractionInfo); + Map writeBinaryInputBasicReliabilityCommandParams = new LinkedHashMap(); CommandParameterInfo binaryInputBasicreliabilityCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBinaryInputBasicReliabilityCommandParams.put( - "value", binaryInputBasicreliabilityCommandParameterInfo); - InteractionInfo writeBinaryInputBasicReliabilityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .writeReliabilityAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicReliabilityCommandParams); - writeBinaryInputBasicInteractionInfo.put( - "writeReliabilityAttribute", writeBinaryInputBasicReliabilityAttributeInteractionInfo); + "value", + binaryInputBasicreliabilityCommandParameterInfo + ); + InteractionInfo writeBinaryInputBasicReliabilityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).writeReliabilityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicReliabilityCommandParams + ); + writeBinaryInputBasicInteractionInfo.put("writeReliabilityAttribute", writeBinaryInputBasicReliabilityAttributeInteractionInfo); writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); Map writePulseWidthModulationInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("pulseWidthModulation", writePulseWidthModulationInteractionInfo); @@ -356,189 +447,222 @@ public Map> getWriteAttributeMap() { Map writeActionsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("actions", writeActionsInteractionInfo); Map writeBasicInformationInteractionInfo = new LinkedHashMap<>(); - Map writeBasicInformationNodeLabelCommandParams = - new LinkedHashMap(); + Map writeBasicInformationNodeLabelCommandParams = new LinkedHashMap(); CommandParameterInfo basicInformationnodeLabelCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBasicInformationNodeLabelCommandParams.put( - "value", basicInformationnodeLabelCommandParameterInfo); - InteractionInfo writeBasicInformationNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .writeNodeLabelAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicInformationNodeLabelCommandParams); - writeBasicInformationInteractionInfo.put( - "writeNodeLabelAttribute", writeBasicInformationNodeLabelAttributeInteractionInfo); - Map writeBasicInformationLocationCommandParams = - new LinkedHashMap(); + "value", + basicInformationnodeLabelCommandParameterInfo + ); + InteractionInfo writeBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).writeNodeLabelAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicInformationNodeLabelCommandParams + ); + writeBasicInformationInteractionInfo.put("writeNodeLabelAttribute", writeBasicInformationNodeLabelAttributeInteractionInfo); + Map writeBasicInformationLocationCommandParams = new LinkedHashMap(); CommandParameterInfo basicInformationlocationCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBasicInformationLocationCommandParams.put( - "value", basicInformationlocationCommandParameterInfo); - InteractionInfo writeBasicInformationLocationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .writeLocationAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicInformationLocationCommandParams); - writeBasicInformationInteractionInfo.put( - "writeLocationAttribute", writeBasicInformationLocationAttributeInteractionInfo); - Map writeBasicInformationLocalConfigDisabledCommandParams = - new LinkedHashMap(); + "value", + basicInformationlocationCommandParameterInfo + ); + InteractionInfo writeBasicInformationLocationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).writeLocationAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicInformationLocationCommandParams + ); + writeBasicInformationInteractionInfo.put("writeLocationAttribute", writeBasicInformationLocationAttributeInteractionInfo); + Map writeBasicInformationLocalConfigDisabledCommandParams = new LinkedHashMap(); CommandParameterInfo basicInformationlocalConfigDisabledCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeBasicInformationLocalConfigDisabledCommandParams.put( - "value", basicInformationlocalConfigDisabledCommandParameterInfo); - InteractionInfo writeBasicInformationLocalConfigDisabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster) - .writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicInformationLocalConfigDisabledCommandParams); - writeBasicInformationInteractionInfo.put( - "writeLocalConfigDisabledAttribute", - writeBasicInformationLocalConfigDisabledAttributeInteractionInfo); + "value", + basicInformationlocalConfigDisabledCommandParameterInfo + ); + InteractionInfo writeBasicInformationLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster).writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicInformationLocalConfigDisabledCommandParams + ); + writeBasicInformationInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicInformationLocalConfigDisabledAttributeInteractionInfo); writeAttributeMap.put("basicInformation", writeBasicInformationInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = - new LinkedHashMap(); + Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeLocalizationConfigurationActiveLocaleCommandParams.put( - "value", localizationConfigurationactiveLocaleCommandParameterInfo); - InteractionInfo writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .writeActiveLocaleAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLocalizationConfigurationActiveLocaleCommandParams); - writeLocalizationConfigurationInteractionInfo.put( - "writeActiveLocaleAttribute", - writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo); - writeAttributeMap.put( - "localizationConfiguration", writeLocalizationConfigurationInteractionInfo); + "value", + localizationConfigurationactiveLocaleCommandParameterInfo + ); + InteractionInfo writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).writeActiveLocaleAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLocalizationConfigurationActiveLocaleCommandParams + ); + writeLocalizationConfigurationInteractionInfo.put("writeActiveLocaleAttribute", writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo); + writeAttributeMap.put("localizationConfiguration", writeLocalizationConfigurationInteractionInfo); Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = - new LinkedHashMap(); + Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeTimeFormatLocalizationHourFormatCommandParams.put( - "value", timeFormatLocalizationhourFormatCommandParameterInfo); - InteractionInfo writeTimeFormatLocalizationHourFormatAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .writeHourFormatAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTimeFormatLocalizationHourFormatCommandParams); - writeTimeFormatLocalizationInteractionInfo.put( - "writeHourFormatAttribute", writeTimeFormatLocalizationHourFormatAttributeInteractionInfo); - Map writeTimeFormatLocalizationActiveCalendarTypeCommandParams = - new LinkedHashMap(); + "value", + timeFormatLocalizationhourFormatCommandParameterInfo + ); + InteractionInfo writeTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).writeHourFormatAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTimeFormatLocalizationHourFormatCommandParams + ); + writeTimeFormatLocalizationInteractionInfo.put("writeHourFormatAttribute", writeTimeFormatLocalizationHourFormatAttributeInteractionInfo); + Map writeTimeFormatLocalizationActiveCalendarTypeCommandParams = new LinkedHashMap(); CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeTimeFormatLocalizationActiveCalendarTypeCommandParams.put( - "value", timeFormatLocalizationactiveCalendarTypeCommandParameterInfo); - InteractionInfo writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .writeActiveCalendarTypeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTimeFormatLocalizationActiveCalendarTypeCommandParams); - writeTimeFormatLocalizationInteractionInfo.put( - "writeActiveCalendarTypeAttribute", - writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); + "value", + timeFormatLocalizationactiveCalendarTypeCommandParameterInfo + ); + InteractionInfo writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).writeActiveCalendarTypeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTimeFormatLocalizationActiveCalendarTypeCommandParams + ); + writeTimeFormatLocalizationInteractionInfo.put("writeActiveCalendarTypeAttribute", writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = - new LinkedHashMap(); + Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitLocalizationTemperatureUnitCommandParams.put( - "value", unitLocalizationtemperatureUnitCommandParameterInfo); - InteractionInfo writeUnitLocalizationTemperatureUnitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .writeTemperatureUnitAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitLocalizationTemperatureUnitCommandParams); - writeUnitLocalizationInteractionInfo.put( - "writeTemperatureUnitAttribute", - writeUnitLocalizationTemperatureUnitAttributeInteractionInfo); + "value", + unitLocalizationtemperatureUnitCommandParameterInfo + ); + InteractionInfo writeUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).writeTemperatureUnitAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitLocalizationTemperatureUnitCommandParams + ); + writeUnitLocalizationInteractionInfo.put("writeTemperatureUnitAttribute", writeUnitLocalizationTemperatureUnitAttributeInteractionInfo); writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = - new LinkedHashMap<>(); + Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = - new LinkedHashMap(); + Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeGeneralCommissioningBreadcrumbCommandParams.put( - "value", generalCommissioningbreadcrumbCommandParameterInfo); - InteractionInfo writeGeneralCommissioningBreadcrumbAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .writeBreadcrumbAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeGeneralCommissioningBreadcrumbCommandParams); - writeGeneralCommissioningInteractionInfo.put( - "writeBreadcrumbAttribute", writeGeneralCommissioningBreadcrumbAttributeInteractionInfo); + "value", + generalCommissioningbreadcrumbCommandParameterInfo + ); + InteractionInfo writeGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).writeBreadcrumbAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeGeneralCommissioningBreadcrumbCommandParams + ); + writeGeneralCommissioningInteractionInfo.put("writeBreadcrumbAttribute", writeGeneralCommissioningBreadcrumbAttributeInteractionInfo); writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); Map writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = - new LinkedHashMap(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeNetworkCommissioningInterfaceEnabledCommandParams.put( - "value", networkCommissioninginterfaceEnabledCommandParameterInfo); - InteractionInfo writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .writeInterfaceEnabledAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeNetworkCommissioningInterfaceEnabledCommandParams); - writeNetworkCommissioningInteractionInfo.put( - "writeInterfaceEnabledAttribute", - writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + "value", + networkCommissioninginterfaceEnabledCommandParameterInfo + ); + InteractionInfo writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).writeInterfaceEnabledAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeNetworkCommissioningInterfaceEnabledCommandParams + ); + writeNetworkCommissioningInteractionInfo.put("writeInterfaceEnabledAttribute", writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); @@ -546,45 +670,42 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeThreadNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); + Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); Map writeTimeSynchronizationInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("timeSynchronization", writeTimeSynchronizationInteractionInfo); - Map writeBridgedDeviceBasicInformationInteractionInfo = - new LinkedHashMap<>(); - Map writeBridgedDeviceBasicInformationNodeLabelCommandParams = - new LinkedHashMap(); + Map writeBridgedDeviceBasicInformationInteractionInfo = new LinkedHashMap<>(); + Map writeBridgedDeviceBasicInformationNodeLabelCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedDeviceBasicInformationnodeLabelCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBridgedDeviceBasicInformationNodeLabelCommandParams.put( - "value", bridgedDeviceBasicInformationnodeLabelCommandParameterInfo); - InteractionInfo writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .writeNodeLabelAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBridgedDeviceBasicInformationNodeLabelCommandParams); - writeBridgedDeviceBasicInformationInteractionInfo.put( - "writeNodeLabelAttribute", - writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); - writeAttributeMap.put( - "bridgedDeviceBasicInformation", writeBridgedDeviceBasicInformationInteractionInfo); + "value", + bridgedDeviceBasicInformationnodeLabelCommandParameterInfo + ); + InteractionInfo writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).writeNodeLabelAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBridgedDeviceBasicInformationNodeLabelCommandParams + ); + writeBridgedDeviceBasicInformationInteractionInfo.put("writeNodeLabelAttribute", writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); + writeAttributeMap.put("bridgedDeviceBasicInformation", writeBridgedDeviceBasicInformationInteractionInfo); Map writeSwitchInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); @@ -604,119 +725,140 @@ public Map> getWriteAttributeMap() { Map writeIcdManagementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("icdManagement", writeIcdManagementInteractionInfo); Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectStartUpModeCommandParams = - new LinkedHashMap(); + Map writeModeSelectStartUpModeCommandParams = new LinkedHashMap(); CommandParameterInfo modeSelectstartUpModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeModeSelectStartUpModeCommandParams.put("value", modeSelectstartUpModeCommandParameterInfo); - InteractionInfo writeModeSelectStartUpModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .writeStartUpModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeModeSelectStartUpModeCommandParams); - writeModeSelectInteractionInfo.put( - "writeStartUpModeAttribute", writeModeSelectStartUpModeAttributeInteractionInfo); - Map writeModeSelectOnModeCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeModeSelectStartUpModeCommandParams.put( + "value", + modeSelectstartUpModeCommandParameterInfo + ); + InteractionInfo writeModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).writeStartUpModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeModeSelectStartUpModeCommandParams + ); + writeModeSelectInteractionInfo.put("writeStartUpModeAttribute", writeModeSelectStartUpModeAttributeInteractionInfo); + Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); CommandParameterInfo modeSelectonModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeModeSelectOnModeCommandParams.put("value", modeSelectonModeCommandParameterInfo); - InteractionInfo writeModeSelectOnModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .writeOnModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeModeSelectOnModeCommandParams); - writeModeSelectInteractionInfo.put( - "writeOnModeAttribute", writeModeSelectOnModeAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeModeSelectOnModeCommandParams.put( + "value", + modeSelectonModeCommandParameterInfo + ); + InteractionInfo writeModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).writeOnModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeModeSelectOnModeCommandParams + ); + writeModeSelectInteractionInfo.put("writeOnModeAttribute", writeModeSelectOnModeAttributeInteractionInfo); writeAttributeMap.put("modeSelect", writeModeSelectInteractionInfo); Map writeTemperatureControlInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("temperatureControl", writeTemperatureControlInteractionInfo); Map writeRefrigeratorAlarmInteractionInfo = new LinkedHashMap<>(); - Map writeRefrigeratorAlarmMaskCommandParams = - new LinkedHashMap(); + Map writeRefrigeratorAlarmMaskCommandParams = new LinkedHashMap(); CommandParameterInfo refrigeratorAlarmmaskCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeRefrigeratorAlarmMaskCommandParams.put("value", refrigeratorAlarmmaskCommandParameterInfo); - InteractionInfo writeRefrigeratorAlarmMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster) - .writeMaskAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeRefrigeratorAlarmMaskCommandParams); - writeRefrigeratorAlarmInteractionInfo.put( - "writeMaskAttribute", writeRefrigeratorAlarmMaskAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeRefrigeratorAlarmMaskCommandParams.put( + "value", + refrigeratorAlarmmaskCommandParameterInfo + ); + InteractionInfo writeRefrigeratorAlarmMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster).writeMaskAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeRefrigeratorAlarmMaskCommandParams + ); + writeRefrigeratorAlarmInteractionInfo.put("writeMaskAttribute", writeRefrigeratorAlarmMaskAttributeInteractionInfo); writeAttributeMap.put("refrigeratorAlarm", writeRefrigeratorAlarmInteractionInfo); Map writeAirQualityInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("airQuality", writeAirQualityInteractionInfo); Map writeSmokeCoAlarmInteractionInfo = new LinkedHashMap<>(); - Map writeSmokeCoAlarmSensitivityLevelCommandParams = - new LinkedHashMap(); + Map writeSmokeCoAlarmSensitivityLevelCommandParams = new LinkedHashMap(); CommandParameterInfo smokeCoAlarmsensitivityLevelCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + 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); + "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 writeDishwasherAlarmInteractionInfo = new LinkedHashMap<>(); - Map writeDishwasherAlarmMaskCommandParams = - new LinkedHashMap(); + Map writeDishwasherAlarmMaskCommandParams = new LinkedHashMap(); CommandParameterInfo dishwasherAlarmmaskCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeDishwasherAlarmMaskCommandParams.put("value", dishwasherAlarmmaskCommandParameterInfo); - InteractionInfo writeDishwasherAlarmMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster) - .writeMaskAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDishwasherAlarmMaskCommandParams); - writeDishwasherAlarmInteractionInfo.put( - "writeMaskAttribute", writeDishwasherAlarmMaskAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeDishwasherAlarmMaskCommandParams.put( + "value", + dishwasherAlarmmaskCommandParameterInfo + ); + InteractionInfo writeDishwasherAlarmMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).writeMaskAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDishwasherAlarmMaskCommandParams + ); + writeDishwasherAlarmInteractionInfo.put("writeMaskAttribute", writeDishwasherAlarmMaskAttributeInteractionInfo); writeAttributeMap.put("dishwasherAlarm", writeDishwasherAlarmInteractionInfo); Map writeHepaFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("hepaFilterMonitoring", writeHepaFilterMonitoringInteractionInfo); - Map writeActivatedCarbonFilterMonitoringInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "activatedCarbonFilterMonitoring", writeActivatedCarbonFilterMonitoringInteractionInfo); - Map writeCeramicFilterMonitoringInteractionInfo = - new LinkedHashMap<>(); + Map writeActivatedCarbonFilterMonitoringInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("activatedCarbonFilterMonitoring", writeActivatedCarbonFilterMonitoringInteractionInfo); + Map writeCeramicFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("ceramicFilterMonitoring", writeCeramicFilterMonitoringInteractionInfo); - Map writeElectrostaticFilterMonitoringInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "electrostaticFilterMonitoring", writeElectrostaticFilterMonitoringInteractionInfo); + Map writeElectrostaticFilterMonitoringInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("electrostaticFilterMonitoring", writeElectrostaticFilterMonitoringInteractionInfo); Map writeUvFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("uvFilterMonitoring", writeUvFilterMonitoringInteractionInfo); - Map writeIonizingFilterMonitoringInteractionInfo = - new LinkedHashMap<>(); + Map writeIonizingFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("ionizingFilterMonitoring", writeIonizingFilterMonitoringInteractionInfo); - Map writeZeoliteFilterMonitoringInteractionInfo = - new LinkedHashMap<>(); + Map writeZeoliteFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("zeoliteFilterMonitoring", writeZeoliteFilterMonitoringInteractionInfo); Map writeOzoneFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("ozoneFilterMonitoring", writeOzoneFilterMonitoringInteractionInfo); @@ -726,1578 +868,1961 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("fuelTankMonitoring", writeFuelTankMonitoringInteractionInfo); Map writeInkCartridgeMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("inkCartridgeMonitoring", writeInkCartridgeMonitoringInteractionInfo); - Map writeTonerCartridgeMonitoringInteractionInfo = - new LinkedHashMap<>(); + Map writeTonerCartridgeMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("tonerCartridgeMonitoring", writeTonerCartridgeMonitoringInteractionInfo); Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockDoorOpenEventsCommandParams = - new LinkedHashMap(); + Map writeDoorLockDoorOpenEventsCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockdoorOpenEventsCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeDoorLockDoorOpenEventsCommandParams.put( - "value", doorLockdoorOpenEventsCommandParameterInfo); - InteractionInfo writeDoorLockDoorOpenEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeDoorOpenEventsAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockDoorOpenEventsCommandParams); - writeDoorLockInteractionInfo.put( - "writeDoorOpenEventsAttribute", writeDoorLockDoorOpenEventsAttributeInteractionInfo); - Map writeDoorLockDoorClosedEventsCommandParams = - new LinkedHashMap(); + "value", + doorLockdoorOpenEventsCommandParameterInfo + ); + InteractionInfo writeDoorLockDoorOpenEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeDoorOpenEventsAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockDoorOpenEventsCommandParams + ); + writeDoorLockInteractionInfo.put("writeDoorOpenEventsAttribute", writeDoorLockDoorOpenEventsAttributeInteractionInfo); + Map writeDoorLockDoorClosedEventsCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockdoorClosedEventsCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeDoorLockDoorClosedEventsCommandParams.put( - "value", doorLockdoorClosedEventsCommandParameterInfo); - InteractionInfo writeDoorLockDoorClosedEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeDoorClosedEventsAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockDoorClosedEventsCommandParams); - writeDoorLockInteractionInfo.put( - "writeDoorClosedEventsAttribute", writeDoorLockDoorClosedEventsAttributeInteractionInfo); - Map writeDoorLockOpenPeriodCommandParams = - new LinkedHashMap(); + "value", + doorLockdoorClosedEventsCommandParameterInfo + ); + InteractionInfo writeDoorLockDoorClosedEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeDoorClosedEventsAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockDoorClosedEventsCommandParams + ); + writeDoorLockInteractionInfo.put("writeDoorClosedEventsAttribute", writeDoorLockDoorClosedEventsAttributeInteractionInfo); + Map writeDoorLockOpenPeriodCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockopenPeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeDoorLockOpenPeriodCommandParams.put("value", doorLockopenPeriodCommandParameterInfo); - InteractionInfo writeDoorLockOpenPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeOpenPeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockOpenPeriodCommandParams); - writeDoorLockInteractionInfo.put( - "writeOpenPeriodAttribute", writeDoorLockOpenPeriodAttributeInteractionInfo); - Map writeDoorLockLanguageCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeDoorLockOpenPeriodCommandParams.put( + "value", + doorLockopenPeriodCommandParameterInfo + ); + InteractionInfo writeDoorLockOpenPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeOpenPeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockOpenPeriodCommandParams + ); + writeDoorLockInteractionInfo.put("writeOpenPeriodAttribute", writeDoorLockOpenPeriodAttributeInteractionInfo); + Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocklanguageCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); - writeDoorLockLanguageCommandParams.put("value", doorLocklanguageCommandParameterInfo); - InteractionInfo writeDoorLockLanguageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeLanguageAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockLanguageCommandParams); - writeDoorLockInteractionInfo.put( - "writeLanguageAttribute", writeDoorLockLanguageAttributeInteractionInfo); - Map writeDoorLockLEDSettingsCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + String.class, + String.class + ); + writeDoorLockLanguageCommandParams.put( + "value", + doorLocklanguageCommandParameterInfo + ); + InteractionInfo writeDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeLanguageAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockLanguageCommandParams + ); + writeDoorLockInteractionInfo.put("writeLanguageAttribute", writeDoorLockLanguageAttributeInteractionInfo); + Map writeDoorLockLEDSettingsCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockLEDSettingsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeDoorLockLEDSettingsCommandParams.put("value", doorLockLEDSettingsCommandParameterInfo); - InteractionInfo writeDoorLockLEDSettingsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeLEDSettingsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockLEDSettingsCommandParams); - writeDoorLockInteractionInfo.put( - "writeLEDSettingsAttribute", writeDoorLockLEDSettingsAttributeInteractionInfo); - Map writeDoorLockAutoRelockTimeCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeDoorLockLEDSettingsCommandParams.put( + "value", + doorLockLEDSettingsCommandParameterInfo + ); + InteractionInfo writeDoorLockLEDSettingsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeLEDSettingsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockLEDSettingsCommandParams + ); + writeDoorLockInteractionInfo.put("writeLEDSettingsAttribute", writeDoorLockLEDSettingsAttributeInteractionInfo); + Map writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeDoorLockAutoRelockTimeCommandParams.put( - "value", doorLockautoRelockTimeCommandParameterInfo); - InteractionInfo writeDoorLockAutoRelockTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeAutoRelockTimeAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockAutoRelockTimeCommandParams); - writeDoorLockInteractionInfo.put( - "writeAutoRelockTimeAttribute", writeDoorLockAutoRelockTimeAttributeInteractionInfo); - Map writeDoorLockSoundVolumeCommandParams = - new LinkedHashMap(); + "value", + doorLockautoRelockTimeCommandParameterInfo + ); + InteractionInfo writeDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeAutoRelockTimeAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockAutoRelockTimeCommandParams + ); + writeDoorLockInteractionInfo.put("writeAutoRelockTimeAttribute", writeDoorLockAutoRelockTimeAttributeInteractionInfo); + Map writeDoorLockSoundVolumeCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeDoorLockSoundVolumeCommandParams.put("value", doorLocksoundVolumeCommandParameterInfo); - InteractionInfo writeDoorLockSoundVolumeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeSoundVolumeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockSoundVolumeCommandParams); - writeDoorLockInteractionInfo.put( - "writeSoundVolumeAttribute", writeDoorLockSoundVolumeAttributeInteractionInfo); - Map writeDoorLockOperatingModeCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeDoorLockSoundVolumeCommandParams.put( + "value", + doorLocksoundVolumeCommandParameterInfo + ); + InteractionInfo writeDoorLockSoundVolumeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeSoundVolumeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockSoundVolumeCommandParams + ); + writeDoorLockInteractionInfo.put("writeSoundVolumeAttribute", writeDoorLockSoundVolumeAttributeInteractionInfo); + Map writeDoorLockOperatingModeCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockoperatingModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeDoorLockOperatingModeCommandParams.put("value", doorLockoperatingModeCommandParameterInfo); - InteractionInfo writeDoorLockOperatingModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeOperatingModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockOperatingModeCommandParams); - writeDoorLockInteractionInfo.put( - "writeOperatingModeAttribute", writeDoorLockOperatingModeAttributeInteractionInfo); - Map writeDoorLockEnableLocalProgrammingCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeDoorLockOperatingModeCommandParams.put( + "value", + doorLockoperatingModeCommandParameterInfo + ); + InteractionInfo writeDoorLockOperatingModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeOperatingModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockOperatingModeCommandParams + ); + writeDoorLockInteractionInfo.put("writeOperatingModeAttribute", writeDoorLockOperatingModeAttributeInteractionInfo); + Map writeDoorLockEnableLocalProgrammingCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockenableLocalProgrammingCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeDoorLockEnableLocalProgrammingCommandParams.put( - "value", doorLockenableLocalProgrammingCommandParameterInfo); - InteractionInfo writeDoorLockEnableLocalProgrammingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeEnableLocalProgrammingAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnableLocalProgrammingCommandParams); - writeDoorLockInteractionInfo.put( - "writeEnableLocalProgrammingAttribute", - writeDoorLockEnableLocalProgrammingAttributeInteractionInfo); - Map writeDoorLockEnableOneTouchLockingCommandParams = - new LinkedHashMap(); + "value", + doorLockenableLocalProgrammingCommandParameterInfo + ); + InteractionInfo writeDoorLockEnableLocalProgrammingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeEnableLocalProgrammingAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnableLocalProgrammingCommandParams + ); + writeDoorLockInteractionInfo.put("writeEnableLocalProgrammingAttribute", writeDoorLockEnableLocalProgrammingAttributeInteractionInfo); + Map writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeDoorLockEnableOneTouchLockingCommandParams.put( - "value", doorLockenableOneTouchLockingCommandParameterInfo); - InteractionInfo writeDoorLockEnableOneTouchLockingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeEnableOneTouchLockingAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnableOneTouchLockingCommandParams); - writeDoorLockInteractionInfo.put( - "writeEnableOneTouchLockingAttribute", - writeDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map writeDoorLockEnableInsideStatusLEDCommandParams = - new LinkedHashMap(); + "value", + doorLockenableOneTouchLockingCommandParameterInfo + ); + InteractionInfo writeDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeEnableOneTouchLockingAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnableOneTouchLockingCommandParams + ); + writeDoorLockInteractionInfo.put("writeEnableOneTouchLockingAttribute", writeDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map writeDoorLockEnableInsideStatusLEDCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockenableInsideStatusLEDCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeDoorLockEnableInsideStatusLEDCommandParams.put( - "value", doorLockenableInsideStatusLEDCommandParameterInfo); - InteractionInfo writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeEnableInsideStatusLEDAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnableInsideStatusLEDCommandParams); - writeDoorLockInteractionInfo.put( - "writeEnableInsideStatusLEDAttribute", - writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo); - Map writeDoorLockEnablePrivacyModeButtonCommandParams = - new LinkedHashMap(); + "value", + doorLockenableInsideStatusLEDCommandParameterInfo + ); + InteractionInfo writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeEnableInsideStatusLEDAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnableInsideStatusLEDCommandParams + ); + writeDoorLockInteractionInfo.put("writeEnableInsideStatusLEDAttribute", writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo); + Map writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeDoorLockEnablePrivacyModeButtonCommandParams.put( - "value", doorLockenablePrivacyModeButtonCommandParameterInfo); - InteractionInfo writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeEnablePrivacyModeButtonAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnablePrivacyModeButtonCommandParams); - writeDoorLockInteractionInfo.put( - "writeEnablePrivacyModeButtonAttribute", - writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map writeDoorLockLocalProgrammingFeaturesCommandParams = - new LinkedHashMap(); + "value", + doorLockenablePrivacyModeButtonCommandParameterInfo + ); + InteractionInfo writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeEnablePrivacyModeButtonAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnablePrivacyModeButtonCommandParams + ); + writeDoorLockInteractionInfo.put("writeEnablePrivacyModeButtonAttribute", writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map writeDoorLockLocalProgrammingFeaturesCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocklocalProgrammingFeaturesCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeDoorLockLocalProgrammingFeaturesCommandParams.put( - "value", doorLocklocalProgrammingFeaturesCommandParameterInfo); - InteractionInfo writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeLocalProgrammingFeaturesAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockLocalProgrammingFeaturesCommandParams); - writeDoorLockInteractionInfo.put( - "writeLocalProgrammingFeaturesAttribute", - writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); - Map writeDoorLockWrongCodeEntryLimitCommandParams = - new LinkedHashMap(); + "value", + doorLocklocalProgrammingFeaturesCommandParameterInfo + ); + InteractionInfo writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeLocalProgrammingFeaturesAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockLocalProgrammingFeaturesCommandParams + ); + writeDoorLockInteractionInfo.put("writeLocalProgrammingFeaturesAttribute", writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); + Map writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeDoorLockWrongCodeEntryLimitCommandParams.put( - "value", doorLockwrongCodeEntryLimitCommandParameterInfo); - InteractionInfo writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeWrongCodeEntryLimitAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockWrongCodeEntryLimitCommandParams); - writeDoorLockInteractionInfo.put( - "writeWrongCodeEntryLimitAttribute", - writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map writeDoorLockUserCodeTemporaryDisableTimeCommandParams = - new LinkedHashMap(); + "value", + doorLockwrongCodeEntryLimitCommandParameterInfo + ); + InteractionInfo writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeWrongCodeEntryLimitAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockWrongCodeEntryLimitCommandParams + ); + writeDoorLockInteractionInfo.put("writeWrongCodeEntryLimitAttribute", writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map writeDoorLockUserCodeTemporaryDisableTimeCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockuserCodeTemporaryDisableTimeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeDoorLockUserCodeTemporaryDisableTimeCommandParams.put( - "value", doorLockuserCodeTemporaryDisableTimeCommandParameterInfo); - InteractionInfo writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeUserCodeTemporaryDisableTimeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockUserCodeTemporaryDisableTimeCommandParams); - writeDoorLockInteractionInfo.put( - "writeUserCodeTemporaryDisableTimeAttribute", - writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); - Map writeDoorLockSendPINOverTheAirCommandParams = - new LinkedHashMap(); + "value", + doorLockuserCodeTemporaryDisableTimeCommandParameterInfo + ); + InteractionInfo writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeUserCodeTemporaryDisableTimeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockUserCodeTemporaryDisableTimeCommandParams + ); + writeDoorLockInteractionInfo.put("writeUserCodeTemporaryDisableTimeAttribute", writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); + Map writeDoorLockSendPINOverTheAirCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksendPINOverTheAirCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeDoorLockSendPINOverTheAirCommandParams.put( - "value", doorLocksendPINOverTheAirCommandParameterInfo); - InteractionInfo writeDoorLockSendPINOverTheAirAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeSendPINOverTheAirAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockSendPINOverTheAirCommandParams); - writeDoorLockInteractionInfo.put( - "writeSendPINOverTheAirAttribute", writeDoorLockSendPINOverTheAirAttributeInteractionInfo); - Map writeDoorLockRequirePINforRemoteOperationCommandParams = - new LinkedHashMap(); + "value", + doorLocksendPINOverTheAirCommandParameterInfo + ); + InteractionInfo writeDoorLockSendPINOverTheAirAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeSendPINOverTheAirAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockSendPINOverTheAirCommandParams + ); + writeDoorLockInteractionInfo.put("writeSendPINOverTheAirAttribute", writeDoorLockSendPINOverTheAirAttributeInteractionInfo); + Map writeDoorLockRequirePINforRemoteOperationCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockrequirePINforRemoteOperationCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeDoorLockRequirePINforRemoteOperationCommandParams.put( - "value", doorLockrequirePINforRemoteOperationCommandParameterInfo); - InteractionInfo writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeRequirePINforRemoteOperationAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockRequirePINforRemoteOperationCommandParams); - writeDoorLockInteractionInfo.put( - "writeRequirePINforRemoteOperationAttribute", - writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); - Map writeDoorLockExpiringUserTimeoutCommandParams = - new LinkedHashMap(); + "value", + doorLockrequirePINforRemoteOperationCommandParameterInfo + ); + InteractionInfo writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeRequirePINforRemoteOperationAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockRequirePINforRemoteOperationCommandParams + ); + writeDoorLockInteractionInfo.put("writeRequirePINforRemoteOperationAttribute", writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); + Map writeDoorLockExpiringUserTimeoutCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockexpiringUserTimeoutCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeDoorLockExpiringUserTimeoutCommandParams.put( - "value", doorLockexpiringUserTimeoutCommandParameterInfo); - InteractionInfo writeDoorLockExpiringUserTimeoutAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .writeExpiringUserTimeoutAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockExpiringUserTimeoutCommandParams); - writeDoorLockInteractionInfo.put( - "writeExpiringUserTimeoutAttribute", - writeDoorLockExpiringUserTimeoutAttributeInteractionInfo); + "value", + doorLockexpiringUserTimeoutCommandParameterInfo + ); + InteractionInfo writeDoorLockExpiringUserTimeoutAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).writeExpiringUserTimeoutAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockExpiringUserTimeoutCommandParams + ); + writeDoorLockInteractionInfo.put("writeExpiringUserTimeoutAttribute", writeDoorLockExpiringUserTimeoutAttributeInteractionInfo); writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = - new LinkedHashMap(); + Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringmodeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeWindowCoveringModeCommandParams.put("value", windowCoveringmodeCommandParameterInfo); - InteractionInfo writeWindowCoveringModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .writeModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeWindowCoveringModeCommandParams); - writeWindowCoveringInteractionInfo.put( - "writeModeAttribute", writeWindowCoveringModeAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeWindowCoveringModeCommandParams.put( + "value", + windowCoveringmodeCommandParameterInfo + ); + InteractionInfo writeWindowCoveringModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).writeModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeWindowCoveringModeCommandParams + ); + writeWindowCoveringInteractionInfo.put("writeModeAttribute", writeWindowCoveringModeAttributeInteractionInfo); writeAttributeMap.put("windowCovering", writeWindowCoveringInteractionInfo); Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map writeBarrierControlBarrierOpenEventsCommandParams = - new LinkedHashMap(); + Map writeBarrierControlBarrierOpenEventsCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierOpenEventsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBarrierControlBarrierOpenEventsCommandParams.put( - "value", barrierControlbarrierOpenEventsCommandParameterInfo); - InteractionInfo writeBarrierControlBarrierOpenEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .writeBarrierOpenEventsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierOpenEventsCommandParams); - writeBarrierControlInteractionInfo.put( - "writeBarrierOpenEventsAttribute", - writeBarrierControlBarrierOpenEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierCloseEventsCommandParams = - new LinkedHashMap(); + "value", + barrierControlbarrierOpenEventsCommandParameterInfo + ); + InteractionInfo writeBarrierControlBarrierOpenEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).writeBarrierOpenEventsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierOpenEventsCommandParams + ); + writeBarrierControlInteractionInfo.put("writeBarrierOpenEventsAttribute", writeBarrierControlBarrierOpenEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierCloseEventsCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierCloseEventsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBarrierControlBarrierCloseEventsCommandParams.put( - "value", barrierControlbarrierCloseEventsCommandParameterInfo); - InteractionInfo writeBarrierControlBarrierCloseEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .writeBarrierCloseEventsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierCloseEventsCommandParams); - writeBarrierControlInteractionInfo.put( - "writeBarrierCloseEventsAttribute", - writeBarrierControlBarrierCloseEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierCommandOpenEventsCommandParams = - new LinkedHashMap(); + "value", + barrierControlbarrierCloseEventsCommandParameterInfo + ); + InteractionInfo writeBarrierControlBarrierCloseEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).writeBarrierCloseEventsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierCloseEventsCommandParams + ); + writeBarrierControlInteractionInfo.put("writeBarrierCloseEventsAttribute", writeBarrierControlBarrierCloseEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierCommandOpenEventsCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierCommandOpenEventsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBarrierControlBarrierCommandOpenEventsCommandParams.put( - "value", barrierControlbarrierCommandOpenEventsCommandParameterInfo); - InteractionInfo writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .writeBarrierCommandOpenEventsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierCommandOpenEventsCommandParams); - writeBarrierControlInteractionInfo.put( - "writeBarrierCommandOpenEventsAttribute", - writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierCommandCloseEventsCommandParams = - new LinkedHashMap(); + "value", + barrierControlbarrierCommandOpenEventsCommandParameterInfo + ); + InteractionInfo writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).writeBarrierCommandOpenEventsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierCommandOpenEventsCommandParams + ); + writeBarrierControlInteractionInfo.put("writeBarrierCommandOpenEventsAttribute", writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierCommandCloseEventsCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierCommandCloseEventsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBarrierControlBarrierCommandCloseEventsCommandParams.put( - "value", barrierControlbarrierCommandCloseEventsCommandParameterInfo); - InteractionInfo writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .writeBarrierCommandCloseEventsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierCommandCloseEventsCommandParams); - writeBarrierControlInteractionInfo.put( - "writeBarrierCommandCloseEventsAttribute", - writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierOpenPeriodCommandParams = - new LinkedHashMap(); + "value", + barrierControlbarrierCommandCloseEventsCommandParameterInfo + ); + InteractionInfo writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).writeBarrierCommandCloseEventsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierCommandCloseEventsCommandParams + ); + writeBarrierControlInteractionInfo.put("writeBarrierCommandCloseEventsAttribute", writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierOpenPeriodCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierOpenPeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBarrierControlBarrierOpenPeriodCommandParams.put( - "value", barrierControlbarrierOpenPeriodCommandParameterInfo); - InteractionInfo writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .writeBarrierOpenPeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierOpenPeriodCommandParams); - writeBarrierControlInteractionInfo.put( - "writeBarrierOpenPeriodAttribute", - writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo); - Map writeBarrierControlBarrierClosePeriodCommandParams = - new LinkedHashMap(); + "value", + barrierControlbarrierOpenPeriodCommandParameterInfo + ); + InteractionInfo writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).writeBarrierOpenPeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierOpenPeriodCommandParams + ); + writeBarrierControlInteractionInfo.put("writeBarrierOpenPeriodAttribute", writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo); + Map writeBarrierControlBarrierClosePeriodCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierClosePeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBarrierControlBarrierClosePeriodCommandParams.put( - "value", barrierControlbarrierClosePeriodCommandParameterInfo); - InteractionInfo writeBarrierControlBarrierClosePeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .writeBarrierClosePeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierClosePeriodCommandParams); - writeBarrierControlInteractionInfo.put( - "writeBarrierClosePeriodAttribute", - writeBarrierControlBarrierClosePeriodAttributeInteractionInfo); + "value", + barrierControlbarrierClosePeriodCommandParameterInfo + ); + InteractionInfo writeBarrierControlBarrierClosePeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).writeBarrierClosePeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierClosePeriodCommandParams + ); + writeBarrierControlInteractionInfo.put("writeBarrierClosePeriodAttribute", writeBarrierControlBarrierClosePeriodAttributeInteractionInfo); writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = - new LinkedHashMap<>(); - Map - writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = - new LinkedHashMap(); + Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); + Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writePumpConfigurationAndControlLifetimeRunningHoursCommandParams.put( - "value", pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo); - InteractionInfo writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .writeLifetimeRunningHoursAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlLifetimeRunningHoursCommandParams); - writePumpConfigurationAndControlInteractionInfo.put( - "writeLifetimeRunningHoursAttribute", - writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map - writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = - new LinkedHashMap(); + "value", + pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo + ); + InteractionInfo writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeLifetimeRunningHoursAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlLifetimeRunningHoursCommandParams + ); + writePumpConfigurationAndControlInteractionInfo.put("writeLifetimeRunningHoursAttribute", writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams.put( - "value", pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo); - InteractionInfo writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .writeLifetimeEnergyConsumedAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); - writePumpConfigurationAndControlInteractionInfo.put( - "writeLifetimeEnergyConsumedAttribute", - writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); - Map writePumpConfigurationAndControlOperationModeCommandParams = - new LinkedHashMap(); + "value", + pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo + ); + InteractionInfo writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeLifetimeEnergyConsumedAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams + ); + writePumpConfigurationAndControlInteractionInfo.put("writeLifetimeEnergyConsumedAttribute", writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); + Map writePumpConfigurationAndControlOperationModeCommandParams = new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writePumpConfigurationAndControlOperationModeCommandParams.put( - "value", pumpConfigurationAndControloperationModeCommandParameterInfo); - InteractionInfo writePumpConfigurationAndControlOperationModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .writeOperationModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlOperationModeCommandParams); - writePumpConfigurationAndControlInteractionInfo.put( - "writeOperationModeAttribute", - writePumpConfigurationAndControlOperationModeAttributeInteractionInfo); - Map writePumpConfigurationAndControlControlModeCommandParams = - new LinkedHashMap(); + "value", + pumpConfigurationAndControloperationModeCommandParameterInfo + ); + InteractionInfo writePumpConfigurationAndControlOperationModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeOperationModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlOperationModeCommandParams + ); + writePumpConfigurationAndControlInteractionInfo.put("writeOperationModeAttribute", writePumpConfigurationAndControlOperationModeAttributeInteractionInfo); + Map writePumpConfigurationAndControlControlModeCommandParams = new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writePumpConfigurationAndControlControlModeCommandParams.put( - "value", pumpConfigurationAndControlcontrolModeCommandParameterInfo); - InteractionInfo writePumpConfigurationAndControlControlModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .writeControlModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlControlModeCommandParams); - writePumpConfigurationAndControlInteractionInfo.put( - "writeControlModeAttribute", - writePumpConfigurationAndControlControlModeAttributeInteractionInfo); - writeAttributeMap.put( - "pumpConfigurationAndControl", writePumpConfigurationAndControlInteractionInfo); + "value", + pumpConfigurationAndControlcontrolModeCommandParameterInfo + ); + InteractionInfo writePumpConfigurationAndControlControlModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeControlModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlControlModeCommandParams + ); + writePumpConfigurationAndControlInteractionInfo.put("writeControlModeAttribute", writePumpConfigurationAndControlControlModeAttributeInteractionInfo); + writeAttributeMap.put("pumpConfigurationAndControl", writePumpConfigurationAndControlInteractionInfo); Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatHVACSystemTypeConfigurationCommandParams = - new LinkedHashMap(); + Map writeThermostatHVACSystemTypeConfigurationCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatHVACSystemTypeConfigurationCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatHVACSystemTypeConfigurationCommandParams.put( - "value", thermostatHVACSystemTypeConfigurationCommandParameterInfo); - InteractionInfo writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeHVACSystemTypeConfigurationAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatHVACSystemTypeConfigurationCommandParams); - writeThermostatInteractionInfo.put( - "writeHVACSystemTypeConfigurationAttribute", - writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); - Map writeThermostatLocalTemperatureCalibrationCommandParams = - new LinkedHashMap(); + "value", + thermostatHVACSystemTypeConfigurationCommandParameterInfo + ); + InteractionInfo writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeHVACSystemTypeConfigurationAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatHVACSystemTypeConfigurationCommandParams + ); + writeThermostatInteractionInfo.put("writeHVACSystemTypeConfigurationAttribute", writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); + Map writeThermostatLocalTemperatureCalibrationCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatlocalTemperatureCalibrationCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatLocalTemperatureCalibrationCommandParams.put( - "value", thermostatlocalTemperatureCalibrationCommandParameterInfo); - InteractionInfo writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeLocalTemperatureCalibrationAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatLocalTemperatureCalibrationCommandParams); - writeThermostatInteractionInfo.put( - "writeLocalTemperatureCalibrationAttribute", - writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo); - Map writeThermostatOccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); + "value", + thermostatlocalTemperatureCalibrationCommandParameterInfo + ); + InteractionInfo writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeLocalTemperatureCalibrationAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatLocalTemperatureCalibrationCommandParams + ); + writeThermostatInteractionInfo.put("writeLocalTemperatureCalibrationAttribute", writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo); + Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatOccupiedCoolingSetpointCommandParams.put( - "value", thermostatoccupiedCoolingSetpointCommandParameterInfo); - InteractionInfo writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeOccupiedCoolingSetpointAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatOccupiedCoolingSetpointCommandParams); - writeThermostatInteractionInfo.put( - "writeOccupiedCoolingSetpointAttribute", - writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo); - Map writeThermostatOccupiedHeatingSetpointCommandParams = - new LinkedHashMap(); + "value", + thermostatoccupiedCoolingSetpointCommandParameterInfo + ); + InteractionInfo writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeOccupiedCoolingSetpointAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatOccupiedCoolingSetpointCommandParams + ); + writeThermostatInteractionInfo.put("writeOccupiedCoolingSetpointAttribute", writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo); + Map writeThermostatOccupiedHeatingSetpointCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatOccupiedHeatingSetpointCommandParams.put( - "value", thermostatoccupiedHeatingSetpointCommandParameterInfo); - InteractionInfo writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeOccupiedHeatingSetpointAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatOccupiedHeatingSetpointCommandParams); - writeThermostatInteractionInfo.put( - "writeOccupiedHeatingSetpointAttribute", - writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map writeThermostatUnoccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); + "value", + thermostatoccupiedHeatingSetpointCommandParameterInfo + ); + InteractionInfo writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeOccupiedHeatingSetpointAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatOccupiedHeatingSetpointCommandParams + ); + writeThermostatInteractionInfo.put("writeOccupiedHeatingSetpointAttribute", writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map writeThermostatUnoccupiedCoolingSetpointCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatunoccupiedCoolingSetpointCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatUnoccupiedCoolingSetpointCommandParams.put( - "value", thermostatunoccupiedCoolingSetpointCommandParameterInfo); - InteractionInfo writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeUnoccupiedCoolingSetpointAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUnoccupiedCoolingSetpointCommandParams); - writeThermostatInteractionInfo.put( - "writeUnoccupiedCoolingSetpointAttribute", - writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); - Map writeThermostatUnoccupiedHeatingSetpointCommandParams = - new LinkedHashMap(); + "value", + thermostatunoccupiedCoolingSetpointCommandParameterInfo + ); + InteractionInfo writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeUnoccupiedCoolingSetpointAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUnoccupiedCoolingSetpointCommandParams + ); + writeThermostatInteractionInfo.put("writeUnoccupiedCoolingSetpointAttribute", writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); + Map writeThermostatUnoccupiedHeatingSetpointCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatunoccupiedHeatingSetpointCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatUnoccupiedHeatingSetpointCommandParams.put( - "value", thermostatunoccupiedHeatingSetpointCommandParameterInfo); - InteractionInfo writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeUnoccupiedHeatingSetpointAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUnoccupiedHeatingSetpointCommandParams); - writeThermostatInteractionInfo.put( - "writeUnoccupiedHeatingSetpointAttribute", - writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); - Map writeThermostatMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); + "value", + thermostatunoccupiedHeatingSetpointCommandParameterInfo + ); + InteractionInfo writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeUnoccupiedHeatingSetpointAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUnoccupiedHeatingSetpointCommandParams + ); + writeThermostatInteractionInfo.put("writeUnoccupiedHeatingSetpointAttribute", writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); + Map writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatMinHeatSetpointLimitCommandParams.put( - "value", thermostatminHeatSetpointLimitCommandParameterInfo); - InteractionInfo writeThermostatMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeMinHeatSetpointLimitAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMinHeatSetpointLimitCommandParams); - writeThermostatInteractionInfo.put( - "writeMinHeatSetpointLimitAttribute", - writeThermostatMinHeatSetpointLimitAttributeInteractionInfo); - Map writeThermostatMaxHeatSetpointLimitCommandParams = - new LinkedHashMap(); + "value", + thermostatminHeatSetpointLimitCommandParameterInfo + ); + InteractionInfo writeThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeMinHeatSetpointLimitAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMinHeatSetpointLimitCommandParams + ); + writeThermostatInteractionInfo.put("writeMinHeatSetpointLimitAttribute", writeThermostatMinHeatSetpointLimitAttributeInteractionInfo); + Map writeThermostatMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatMaxHeatSetpointLimitCommandParams.put( - "value", thermostatmaxHeatSetpointLimitCommandParameterInfo); - InteractionInfo writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeMaxHeatSetpointLimitAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMaxHeatSetpointLimitCommandParams); - writeThermostatInteractionInfo.put( - "writeMaxHeatSetpointLimitAttribute", - writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo); - Map writeThermostatMinCoolSetpointLimitCommandParams = - new LinkedHashMap(); + "value", + thermostatmaxHeatSetpointLimitCommandParameterInfo + ); + InteractionInfo writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeMaxHeatSetpointLimitAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMaxHeatSetpointLimitCommandParams + ); + writeThermostatInteractionInfo.put("writeMaxHeatSetpointLimitAttribute", writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo); + Map writeThermostatMinCoolSetpointLimitCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatMinCoolSetpointLimitCommandParams.put( - "value", thermostatminCoolSetpointLimitCommandParameterInfo); - InteractionInfo writeThermostatMinCoolSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeMinCoolSetpointLimitAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMinCoolSetpointLimitCommandParams); - writeThermostatInteractionInfo.put( - "writeMinCoolSetpointLimitAttribute", - writeThermostatMinCoolSetpointLimitAttributeInteractionInfo); - Map writeThermostatMaxCoolSetpointLimitCommandParams = - new LinkedHashMap(); + "value", + thermostatminCoolSetpointLimitCommandParameterInfo + ); + InteractionInfo writeThermostatMinCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeMinCoolSetpointLimitAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMinCoolSetpointLimitCommandParams + ); + writeThermostatInteractionInfo.put("writeMinCoolSetpointLimitAttribute", writeThermostatMinCoolSetpointLimitAttributeInteractionInfo); + Map writeThermostatMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatMaxCoolSetpointLimitCommandParams.put( - "value", thermostatmaxCoolSetpointLimitCommandParameterInfo); - InteractionInfo writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeMaxCoolSetpointLimitAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMaxCoolSetpointLimitCommandParams); - writeThermostatInteractionInfo.put( - "writeMaxCoolSetpointLimitAttribute", - writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo); - Map writeThermostatMinSetpointDeadBandCommandParams = - new LinkedHashMap(); + "value", + thermostatmaxCoolSetpointLimitCommandParameterInfo + ); + InteractionInfo writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeMaxCoolSetpointLimitAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMaxCoolSetpointLimitCommandParams + ); + writeThermostatInteractionInfo.put("writeMaxCoolSetpointLimitAttribute", writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo); + Map writeThermostatMinSetpointDeadBandCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatMinSetpointDeadBandCommandParams.put( - "value", thermostatminSetpointDeadBandCommandParameterInfo); - InteractionInfo writeThermostatMinSetpointDeadBandAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeMinSetpointDeadBandAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMinSetpointDeadBandCommandParams); - writeThermostatInteractionInfo.put( - "writeMinSetpointDeadBandAttribute", - writeThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map writeThermostatRemoteSensingCommandParams = - new LinkedHashMap(); + "value", + thermostatminSetpointDeadBandCommandParameterInfo + ); + InteractionInfo writeThermostatMinSetpointDeadBandAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeMinSetpointDeadBandAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMinSetpointDeadBandCommandParams + ); + writeThermostatInteractionInfo.put("writeMinSetpointDeadBandAttribute", writeThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map writeThermostatRemoteSensingCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatremoteSensingCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatRemoteSensingCommandParams.put( - "value", thermostatremoteSensingCommandParameterInfo); - InteractionInfo writeThermostatRemoteSensingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeRemoteSensingAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatRemoteSensingCommandParams); - writeThermostatInteractionInfo.put( - "writeRemoteSensingAttribute", writeThermostatRemoteSensingAttributeInteractionInfo); - Map writeThermostatControlSequenceOfOperationCommandParams = - new LinkedHashMap(); + "value", + thermostatremoteSensingCommandParameterInfo + ); + InteractionInfo writeThermostatRemoteSensingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeRemoteSensingAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatRemoteSensingCommandParams + ); + writeThermostatInteractionInfo.put("writeRemoteSensingAttribute", writeThermostatRemoteSensingAttributeInteractionInfo); + Map writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatControlSequenceOfOperationCommandParams.put( - "value", thermostatcontrolSequenceOfOperationCommandParameterInfo); - InteractionInfo writeThermostatControlSequenceOfOperationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeControlSequenceOfOperationAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatControlSequenceOfOperationCommandParams); - writeThermostatInteractionInfo.put( - "writeControlSequenceOfOperationAttribute", - writeThermostatControlSequenceOfOperationAttributeInteractionInfo); - Map writeThermostatSystemModeCommandParams = - new LinkedHashMap(); + "value", + thermostatcontrolSequenceOfOperationCommandParameterInfo + ); + InteractionInfo writeThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeControlSequenceOfOperationAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatControlSequenceOfOperationCommandParams + ); + writeThermostatInteractionInfo.put("writeControlSequenceOfOperationAttribute", writeThermostatControlSequenceOfOperationAttributeInteractionInfo); + Map writeThermostatSystemModeCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsystemModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeThermostatSystemModeCommandParams.put("value", thermostatsystemModeCommandParameterInfo); - InteractionInfo writeThermostatSystemModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeSystemModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatSystemModeCommandParams); - writeThermostatInteractionInfo.put( - "writeSystemModeAttribute", writeThermostatSystemModeAttributeInteractionInfo); - Map writeThermostatTemperatureSetpointHoldCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeThermostatSystemModeCommandParams.put( + "value", + thermostatsystemModeCommandParameterInfo + ); + InteractionInfo writeThermostatSystemModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeSystemModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatSystemModeCommandParams + ); + writeThermostatInteractionInfo.put("writeSystemModeAttribute", writeThermostatSystemModeAttributeInteractionInfo); + Map writeThermostatTemperatureSetpointHoldCommandParams = new LinkedHashMap(); CommandParameterInfo thermostattemperatureSetpointHoldCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatTemperatureSetpointHoldCommandParams.put( - "value", thermostattemperatureSetpointHoldCommandParameterInfo); - InteractionInfo writeThermostatTemperatureSetpointHoldAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeTemperatureSetpointHoldAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatTemperatureSetpointHoldCommandParams); - writeThermostatInteractionInfo.put( - "writeTemperatureSetpointHoldAttribute", - writeThermostatTemperatureSetpointHoldAttributeInteractionInfo); - Map writeThermostatTemperatureSetpointHoldDurationCommandParams = - new LinkedHashMap(); + "value", + thermostattemperatureSetpointHoldCommandParameterInfo + ); + InteractionInfo writeThermostatTemperatureSetpointHoldAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeTemperatureSetpointHoldAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatTemperatureSetpointHoldCommandParams + ); + writeThermostatInteractionInfo.put("writeTemperatureSetpointHoldAttribute", writeThermostatTemperatureSetpointHoldAttributeInteractionInfo); + Map writeThermostatTemperatureSetpointHoldDurationCommandParams = new LinkedHashMap(); CommandParameterInfo thermostattemperatureSetpointHoldDurationCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatTemperatureSetpointHoldDurationCommandParams.put( - "value", thermostattemperatureSetpointHoldDurationCommandParameterInfo); - InteractionInfo writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeTemperatureSetpointHoldDurationAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatTemperatureSetpointHoldDurationCommandParams); - writeThermostatInteractionInfo.put( - "writeTemperatureSetpointHoldDurationAttribute", - writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); - Map - writeThermostatThermostatProgrammingOperationModeCommandParams = - new LinkedHashMap(); + "value", + thermostattemperatureSetpointHoldDurationCommandParameterInfo + ); + InteractionInfo writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeTemperatureSetpointHoldDurationAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatTemperatureSetpointHoldDurationCommandParams + ); + writeThermostatInteractionInfo.put("writeTemperatureSetpointHoldDurationAttribute", writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); + Map writeThermostatThermostatProgrammingOperationModeCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatthermostatProgrammingOperationModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatThermostatProgrammingOperationModeCommandParams.put( - "value", thermostatthermostatProgrammingOperationModeCommandParameterInfo); - InteractionInfo writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeThermostatProgrammingOperationModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatThermostatProgrammingOperationModeCommandParams); - writeThermostatInteractionInfo.put( - "writeThermostatProgrammingOperationModeAttribute", - writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); - Map writeThermostatOccupiedSetbackCommandParams = - new LinkedHashMap(); + "value", + thermostatthermostatProgrammingOperationModeCommandParameterInfo + ); + InteractionInfo writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeThermostatProgrammingOperationModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatThermostatProgrammingOperationModeCommandParams + ); + writeThermostatInteractionInfo.put("writeThermostatProgrammingOperationModeAttribute", writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); + Map writeThermostatOccupiedSetbackCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatoccupiedSetbackCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatOccupiedSetbackCommandParams.put( - "value", thermostatoccupiedSetbackCommandParameterInfo); - InteractionInfo writeThermostatOccupiedSetbackAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeOccupiedSetbackAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatOccupiedSetbackCommandParams); - writeThermostatInteractionInfo.put( - "writeOccupiedSetbackAttribute", writeThermostatOccupiedSetbackAttributeInteractionInfo); - Map writeThermostatUnoccupiedSetbackCommandParams = - new LinkedHashMap(); + "value", + thermostatoccupiedSetbackCommandParameterInfo + ); + InteractionInfo writeThermostatOccupiedSetbackAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeOccupiedSetbackAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatOccupiedSetbackCommandParams + ); + writeThermostatInteractionInfo.put("writeOccupiedSetbackAttribute", writeThermostatOccupiedSetbackAttributeInteractionInfo); + Map writeThermostatUnoccupiedSetbackCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatunoccupiedSetbackCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatUnoccupiedSetbackCommandParams.put( - "value", thermostatunoccupiedSetbackCommandParameterInfo); - InteractionInfo writeThermostatUnoccupiedSetbackAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeUnoccupiedSetbackAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUnoccupiedSetbackCommandParams); - writeThermostatInteractionInfo.put( - "writeUnoccupiedSetbackAttribute", - writeThermostatUnoccupiedSetbackAttributeInteractionInfo); - Map writeThermostatEmergencyHeatDeltaCommandParams = - new LinkedHashMap(); + "value", + thermostatunoccupiedSetbackCommandParameterInfo + ); + InteractionInfo writeThermostatUnoccupiedSetbackAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeUnoccupiedSetbackAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUnoccupiedSetbackCommandParams + ); + writeThermostatInteractionInfo.put("writeUnoccupiedSetbackAttribute", writeThermostatUnoccupiedSetbackAttributeInteractionInfo); + Map writeThermostatEmergencyHeatDeltaCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatemergencyHeatDeltaCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatEmergencyHeatDeltaCommandParams.put( - "value", thermostatemergencyHeatDeltaCommandParameterInfo); - InteractionInfo writeThermostatEmergencyHeatDeltaAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeEmergencyHeatDeltaAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatEmergencyHeatDeltaCommandParams); - writeThermostatInteractionInfo.put( - "writeEmergencyHeatDeltaAttribute", - writeThermostatEmergencyHeatDeltaAttributeInteractionInfo); - Map writeThermostatACTypeCommandParams = - new LinkedHashMap(); + "value", + thermostatemergencyHeatDeltaCommandParameterInfo + ); + InteractionInfo writeThermostatEmergencyHeatDeltaAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeEmergencyHeatDeltaAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatEmergencyHeatDeltaCommandParams + ); + writeThermostatInteractionInfo.put("writeEmergencyHeatDeltaAttribute", writeThermostatEmergencyHeatDeltaAttributeInteractionInfo); + Map writeThermostatACTypeCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACTypeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeThermostatACTypeCommandParams.put("value", thermostatACTypeCommandParameterInfo); - InteractionInfo writeThermostatACTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACTypeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACTypeCommandParams); - writeThermostatInteractionInfo.put( - "writeACTypeAttribute", writeThermostatACTypeAttributeInteractionInfo); - Map writeThermostatACCapacityCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeThermostatACTypeCommandParams.put( + "value", + thermostatACTypeCommandParameterInfo + ); + InteractionInfo writeThermostatACTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACTypeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACTypeCommandParams + ); + writeThermostatInteractionInfo.put("writeACTypeAttribute", writeThermostatACTypeAttributeInteractionInfo); + Map writeThermostatACCapacityCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACCapacityCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeThermostatACCapacityCommandParams.put("value", thermostatACCapacityCommandParameterInfo); - InteractionInfo writeThermostatACCapacityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACCapacityAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACCapacityCommandParams); - writeThermostatInteractionInfo.put( - "writeACCapacityAttribute", writeThermostatACCapacityAttributeInteractionInfo); - Map writeThermostatACRefrigerantTypeCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeThermostatACCapacityCommandParams.put( + "value", + thermostatACCapacityCommandParameterInfo + ); + InteractionInfo writeThermostatACCapacityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACCapacityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACCapacityCommandParams + ); + writeThermostatInteractionInfo.put("writeACCapacityAttribute", writeThermostatACCapacityAttributeInteractionInfo); + Map writeThermostatACRefrigerantTypeCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACRefrigerantTypeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatACRefrigerantTypeCommandParams.put( - "value", thermostatACRefrigerantTypeCommandParameterInfo); - InteractionInfo writeThermostatACRefrigerantTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACRefrigerantTypeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACRefrigerantTypeCommandParams); - writeThermostatInteractionInfo.put( - "writeACRefrigerantTypeAttribute", - writeThermostatACRefrigerantTypeAttributeInteractionInfo); - Map writeThermostatACCompressorTypeCommandParams = - new LinkedHashMap(); + "value", + thermostatACRefrigerantTypeCommandParameterInfo + ); + InteractionInfo writeThermostatACRefrigerantTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACRefrigerantTypeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACRefrigerantTypeCommandParams + ); + writeThermostatInteractionInfo.put("writeACRefrigerantTypeAttribute", writeThermostatACRefrigerantTypeAttributeInteractionInfo); + Map writeThermostatACCompressorTypeCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACCompressorTypeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatACCompressorTypeCommandParams.put( - "value", thermostatACCompressorTypeCommandParameterInfo); - InteractionInfo writeThermostatACCompressorTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACCompressorTypeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACCompressorTypeCommandParams); - writeThermostatInteractionInfo.put( - "writeACCompressorTypeAttribute", writeThermostatACCompressorTypeAttributeInteractionInfo); - Map writeThermostatACErrorCodeCommandParams = - new LinkedHashMap(); + "value", + thermostatACCompressorTypeCommandParameterInfo + ); + InteractionInfo writeThermostatACCompressorTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACCompressorTypeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACCompressorTypeCommandParams + ); + writeThermostatInteractionInfo.put("writeACCompressorTypeAttribute", writeThermostatACCompressorTypeAttributeInteractionInfo); + Map writeThermostatACErrorCodeCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACErrorCodeCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeThermostatACErrorCodeCommandParams.put("value", thermostatACErrorCodeCommandParameterInfo); - InteractionInfo writeThermostatACErrorCodeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACErrorCodeAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACErrorCodeCommandParams); - writeThermostatInteractionInfo.put( - "writeACErrorCodeAttribute", writeThermostatACErrorCodeAttributeInteractionInfo); - Map writeThermostatACLouverPositionCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeThermostatACErrorCodeCommandParams.put( + "value", + thermostatACErrorCodeCommandParameterInfo + ); + InteractionInfo writeThermostatACErrorCodeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACErrorCodeAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACErrorCodeCommandParams + ); + writeThermostatInteractionInfo.put("writeACErrorCodeAttribute", writeThermostatACErrorCodeAttributeInteractionInfo); + Map writeThermostatACLouverPositionCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACLouverPositionCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatACLouverPositionCommandParams.put( - "value", thermostatACLouverPositionCommandParameterInfo); - InteractionInfo writeThermostatACLouverPositionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACLouverPositionAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACLouverPositionCommandParams); - writeThermostatInteractionInfo.put( - "writeACLouverPositionAttribute", writeThermostatACLouverPositionAttributeInteractionInfo); - Map writeThermostatACCapacityformatCommandParams = - new LinkedHashMap(); + "value", + thermostatACLouverPositionCommandParameterInfo + ); + InteractionInfo writeThermostatACLouverPositionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACLouverPositionAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACLouverPositionCommandParams + ); + writeThermostatInteractionInfo.put("writeACLouverPositionAttribute", writeThermostatACLouverPositionAttributeInteractionInfo); + Map writeThermostatACCapacityformatCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatACCapacityformatCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatACCapacityformatCommandParams.put( - "value", thermostatACCapacityformatCommandParameterInfo); - InteractionInfo writeThermostatACCapacityformatAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .writeACCapacityformatAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACCapacityformatCommandParams); - writeThermostatInteractionInfo.put( - "writeACCapacityformatAttribute", writeThermostatACCapacityformatAttributeInteractionInfo); + "value", + thermostatACCapacityformatCommandParameterInfo + ); + InteractionInfo writeThermostatACCapacityformatAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).writeACCapacityformatAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACCapacityformatCommandParams + ); + writeThermostatInteractionInfo.put("writeACCapacityformatAttribute", writeThermostatACCapacityformatAttributeInteractionInfo); writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); Map writeFanControlInteractionInfo = new LinkedHashMap<>(); - Map writeFanControlFanModeCommandParams = - new LinkedHashMap(); + Map writeFanControlFanModeCommandParams = new LinkedHashMap(); CommandParameterInfo fanControlfanModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeFanControlFanModeCommandParams.put("value", fanControlfanModeCommandParameterInfo); - InteractionInfo writeFanControlFanModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .writeFanModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlFanModeCommandParams); - writeFanControlInteractionInfo.put( - "writeFanModeAttribute", writeFanControlFanModeAttributeInteractionInfo); - Map writeFanControlFanModeSequenceCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeFanControlFanModeCommandParams.put( + "value", + fanControlfanModeCommandParameterInfo + ); + InteractionInfo writeFanControlFanModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).writeFanModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlFanModeCommandParams + ); + writeFanControlInteractionInfo.put("writeFanModeAttribute", writeFanControlFanModeAttributeInteractionInfo); + Map writeFanControlFanModeSequenceCommandParams = new LinkedHashMap(); CommandParameterInfo fanControlfanModeSequenceCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeFanControlFanModeSequenceCommandParams.put( - "value", fanControlfanModeSequenceCommandParameterInfo); - InteractionInfo writeFanControlFanModeSequenceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .writeFanModeSequenceAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlFanModeSequenceCommandParams); - writeFanControlInteractionInfo.put( - "writeFanModeSequenceAttribute", writeFanControlFanModeSequenceAttributeInteractionInfo); - Map writeFanControlPercentSettingCommandParams = - new LinkedHashMap(); + "value", + fanControlfanModeSequenceCommandParameterInfo + ); + InteractionInfo writeFanControlFanModeSequenceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).writeFanModeSequenceAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlFanModeSequenceCommandParams + ); + writeFanControlInteractionInfo.put("writeFanModeSequenceAttribute", writeFanControlFanModeSequenceAttributeInteractionInfo); + Map writeFanControlPercentSettingCommandParams = new LinkedHashMap(); CommandParameterInfo fanControlpercentSettingCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeFanControlPercentSettingCommandParams.put( - "value", fanControlpercentSettingCommandParameterInfo); - InteractionInfo writeFanControlPercentSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .writePercentSettingAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlPercentSettingCommandParams); - writeFanControlInteractionInfo.put( - "writePercentSettingAttribute", writeFanControlPercentSettingAttributeInteractionInfo); - Map writeFanControlSpeedSettingCommandParams = - new LinkedHashMap(); + "value", + fanControlpercentSettingCommandParameterInfo + ); + InteractionInfo writeFanControlPercentSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).writePercentSettingAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlPercentSettingCommandParams + ); + writeFanControlInteractionInfo.put("writePercentSettingAttribute", writeFanControlPercentSettingAttributeInteractionInfo); + Map writeFanControlSpeedSettingCommandParams = new LinkedHashMap(); CommandParameterInfo fanControlspeedSettingCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeFanControlSpeedSettingCommandParams.put( - "value", fanControlspeedSettingCommandParameterInfo); - InteractionInfo writeFanControlSpeedSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .writeSpeedSettingAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlSpeedSettingCommandParams); - writeFanControlInteractionInfo.put( - "writeSpeedSettingAttribute", writeFanControlSpeedSettingAttributeInteractionInfo); - Map writeFanControlRockSettingCommandParams = - new LinkedHashMap(); + "value", + fanControlspeedSettingCommandParameterInfo + ); + InteractionInfo writeFanControlSpeedSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).writeSpeedSettingAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlSpeedSettingCommandParams + ); + writeFanControlInteractionInfo.put("writeSpeedSettingAttribute", writeFanControlSpeedSettingAttributeInteractionInfo); + Map writeFanControlRockSettingCommandParams = new LinkedHashMap(); CommandParameterInfo fanControlrockSettingCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeFanControlRockSettingCommandParams.put("value", fanControlrockSettingCommandParameterInfo); - InteractionInfo writeFanControlRockSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .writeRockSettingAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlRockSettingCommandParams); - writeFanControlInteractionInfo.put( - "writeRockSettingAttribute", writeFanControlRockSettingAttributeInteractionInfo); - Map writeFanControlWindSettingCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeFanControlRockSettingCommandParams.put( + "value", + fanControlrockSettingCommandParameterInfo + ); + InteractionInfo writeFanControlRockSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).writeRockSettingAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlRockSettingCommandParams + ); + writeFanControlInteractionInfo.put("writeRockSettingAttribute", writeFanControlRockSettingAttributeInteractionInfo); + Map writeFanControlWindSettingCommandParams = new LinkedHashMap(); CommandParameterInfo fanControlwindSettingCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeFanControlWindSettingCommandParams.put("value", fanControlwindSettingCommandParameterInfo); - InteractionInfo writeFanControlWindSettingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster) - .writeWindSettingAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlWindSettingCommandParams); - writeFanControlInteractionInfo.put( - "writeWindSettingAttribute", writeFanControlWindSettingAttributeInteractionInfo); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeFanControlWindSettingCommandParams.put( + "value", + fanControlwindSettingCommandParameterInfo + ); + InteractionInfo writeFanControlWindSettingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster).writeWindSettingAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlWindSettingCommandParams + ); + writeFanControlInteractionInfo.put("writeWindSettingAttribute", writeFanControlWindSettingAttributeInteractionInfo); writeAttributeMap.put("fanControl", writeFanControlInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo - thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams.put( - "value", thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo); - InteractionInfo - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .writeTemperatureDisplayModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); - writeThermostatUserInterfaceConfigurationInteractionInfo.put( - "writeTemperatureDisplayModeAttribute", - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); - Map - writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = - new LinkedHashMap(); + "value", + thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo + ); + InteractionInfo writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).writeTemperatureDisplayModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams + ); + writeThermostatUserInterfaceConfigurationInteractionInfo.put("writeTemperatureDisplayModeAttribute", writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); + Map writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams.put( - "value", thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo); - InteractionInfo writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .writeKeypadLockoutAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams); - writeThermostatUserInterfaceConfigurationInteractionInfo.put( - "writeKeypadLockoutAttribute", - writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); - Map - writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = - new LinkedHashMap(); - CommandParameterInfo - thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + "value", + thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo + ); + InteractionInfo writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).writeKeypadLockoutAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams + ); + writeThermostatUserInterfaceConfigurationInteractionInfo.put("writeKeypadLockoutAttribute", writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); + Map writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams.put( "value", - thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo); - InteractionInfo - writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .writeScheduleProgrammingVisibilityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams); - writeThermostatUserInterfaceConfigurationInteractionInfo.put( - "writeScheduleProgrammingVisibilityAttribute", - writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - writeAttributeMap.put( - "thermostatUserInterfaceConfiguration", - writeThermostatUserInterfaceConfigurationInteractionInfo); + thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo + ); + InteractionInfo writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).writeScheduleProgrammingVisibilityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams + ); + writeThermostatUserInterfaceConfigurationInteractionInfo.put("writeScheduleProgrammingVisibilityAttribute", writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + writeAttributeMap.put("thermostatUserInterfaceConfiguration", writeThermostatUserInterfaceConfigurationInteractionInfo); Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlOptionsCommandParams = - new LinkedHashMap(); + Map writeColorControlOptionsCommandParams = new LinkedHashMap(); CommandParameterInfo colorControloptionsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeColorControlOptionsCommandParams.put("value", colorControloptionsCommandParameterInfo); - InteractionInfo writeColorControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeOptionsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlOptionsCommandParams); - writeColorControlInteractionInfo.put( - "writeOptionsAttribute", writeColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeColorControlOptionsCommandParams.put( + "value", + colorControloptionsCommandParameterInfo + ); + InteractionInfo writeColorControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeOptionsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlOptionsCommandParams + ); + writeColorControlInteractionInfo.put("writeOptionsAttribute", writeColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlwhitePointXCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlWhitePointXCommandParams.put( - "value", colorControlwhitePointXCommandParameterInfo); - InteractionInfo writeColorControlWhitePointXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeWhitePointXAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlWhitePointXCommandParams); - writeColorControlInteractionInfo.put( - "writeWhitePointXAttribute", writeColorControlWhitePointXAttributeInteractionInfo); - Map writeColorControlWhitePointYCommandParams = - new LinkedHashMap(); + "value", + colorControlwhitePointXCommandParameterInfo + ); + InteractionInfo writeColorControlWhitePointXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeWhitePointXAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlWhitePointXCommandParams + ); + writeColorControlInteractionInfo.put("writeWhitePointXAttribute", writeColorControlWhitePointXAttributeInteractionInfo); + Map writeColorControlWhitePointYCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlwhitePointYCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlWhitePointYCommandParams.put( - "value", colorControlwhitePointYCommandParameterInfo); - InteractionInfo writeColorControlWhitePointYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeWhitePointYAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlWhitePointYCommandParams); - writeColorControlInteractionInfo.put( - "writeWhitePointYAttribute", writeColorControlWhitePointYAttributeInteractionInfo); - Map writeColorControlColorPointRXCommandParams = - new LinkedHashMap(); + "value", + colorControlwhitePointYCommandParameterInfo + ); + InteractionInfo writeColorControlWhitePointYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeWhitePointYAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlWhitePointYCommandParams + ); + writeColorControlInteractionInfo.put("writeWhitePointYAttribute", writeColorControlWhitePointYAttributeInteractionInfo); + Map writeColorControlColorPointRXCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointRXCommandParams.put( - "value", colorControlcolorPointRXCommandParameterInfo); - InteractionInfo writeColorControlColorPointRXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointRXAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointRXCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointRXAttribute", writeColorControlColorPointRXAttributeInteractionInfo); - Map writeColorControlColorPointRYCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointRXCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointRXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointRXAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointRXCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointRXAttribute", writeColorControlColorPointRXAttributeInteractionInfo); + Map writeColorControlColorPointRYCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointRYCommandParams.put( - "value", colorControlcolorPointRYCommandParameterInfo); - InteractionInfo writeColorControlColorPointRYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointRYAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointRYCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointRYAttribute", writeColorControlColorPointRYAttributeInteractionInfo); - Map writeColorControlColorPointRIntensityCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointRYCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointRYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointRYAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointRYCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointRYAttribute", writeColorControlColorPointRYAttributeInteractionInfo); + Map writeColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointRIntensityCommandParams.put( - "value", colorControlcolorPointRIntensityCommandParameterInfo); - InteractionInfo writeColorControlColorPointRIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointRIntensityAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointRIntensityCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointRIntensityAttribute", - writeColorControlColorPointRIntensityAttributeInteractionInfo); - Map writeColorControlColorPointGXCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointRIntensityCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointRIntensityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointRIntensityCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointRIntensityAttribute", writeColorControlColorPointRIntensityAttributeInteractionInfo); + Map writeColorControlColorPointGXCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointGXCommandParams.put( - "value", colorControlcolorPointGXCommandParameterInfo); - InteractionInfo writeColorControlColorPointGXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointGXAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointGXCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointGXAttribute", writeColorControlColorPointGXAttributeInteractionInfo); - Map writeColorControlColorPointGYCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointGXCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointGXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointGXAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointGXCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointGXAttribute", writeColorControlColorPointGXAttributeInteractionInfo); + Map writeColorControlColorPointGYCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointGYCommandParams.put( - "value", colorControlcolorPointGYCommandParameterInfo); - InteractionInfo writeColorControlColorPointGYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointGYAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointGYCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointGYAttribute", writeColorControlColorPointGYAttributeInteractionInfo); - Map writeColorControlColorPointGIntensityCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointGYCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointGYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointGYAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointGYCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointGYAttribute", writeColorControlColorPointGYAttributeInteractionInfo); + Map writeColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointGIntensityCommandParams.put( - "value", colorControlcolorPointGIntensityCommandParameterInfo); - InteractionInfo writeColorControlColorPointGIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointGIntensityAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointGIntensityCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointGIntensityAttribute", - writeColorControlColorPointGIntensityAttributeInteractionInfo); - Map writeColorControlColorPointBXCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointGIntensityCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointGIntensityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointGIntensityCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointGIntensityAttribute", writeColorControlColorPointGIntensityAttributeInteractionInfo); + Map writeColorControlColorPointBXCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointBXCommandParams.put( - "value", colorControlcolorPointBXCommandParameterInfo); - InteractionInfo writeColorControlColorPointBXAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointBXAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointBXCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointBXAttribute", writeColorControlColorPointBXAttributeInteractionInfo); - Map writeColorControlColorPointBYCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointBXCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointBXAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointBXAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointBXCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointBXAttribute", writeColorControlColorPointBXAttributeInteractionInfo); + Map writeColorControlColorPointBYCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointBYCommandParams.put( - "value", colorControlcolorPointBYCommandParameterInfo); - InteractionInfo writeColorControlColorPointBYAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointBYAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointBYCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointBYAttribute", writeColorControlColorPointBYAttributeInteractionInfo); - Map writeColorControlColorPointBIntensityCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointBYCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointBYAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointBYAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointBYCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointBYAttribute", writeColorControlColorPointBYAttributeInteractionInfo); + Map writeColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlColorPointBIntensityCommandParams.put( - "value", colorControlcolorPointBIntensityCommandParameterInfo); - InteractionInfo writeColorControlColorPointBIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorPointBIntensityAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointBIntensityCommandParams); - writeColorControlInteractionInfo.put( - "writeColorPointBIntensityAttribute", - writeColorControlColorPointBIntensityAttributeInteractionInfo); - Map writeColorControlStartUpColorTemperatureMiredsCommandParams = - new LinkedHashMap(); + "value", + colorControlcolorPointBIntensityCommandParameterInfo + ); + InteractionInfo writeColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorPointBIntensityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointBIntensityCommandParams + ); + writeColorControlInteractionInfo.put("writeColorPointBIntensityAttribute", writeColorControlColorPointBIntensityAttributeInteractionInfo); + Map writeColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeColorControlStartUpColorTemperatureMiredsCommandParams.put( - "value", colorControlstartUpColorTemperatureMiredsCommandParameterInfo); - InteractionInfo writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeStartUpColorTemperatureMiredsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlStartUpColorTemperatureMiredsCommandParams); - writeColorControlInteractionInfo.put( - "writeStartUpColorTemperatureMiredsAttribute", - writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + "value", + colorControlstartUpColorTemperatureMiredsCommandParameterInfo + ); + InteractionInfo writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeStartUpColorTemperatureMiredsAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlStartUpColorTemperatureMiredsCommandParams + ); + writeColorControlInteractionInfo.put("writeStartUpColorTemperatureMiredsAttribute", writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); Map writeBallastConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeBallastConfigurationMinLevelCommandParams = - new LinkedHashMap(); + Map writeBallastConfigurationMinLevelCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationminLevelCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBallastConfigurationMinLevelCommandParams.put( - "value", ballastConfigurationminLevelCommandParameterInfo); - InteractionInfo writeBallastConfigurationMinLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeMinLevelAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationMinLevelCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeMinLevelAttribute", writeBallastConfigurationMinLevelAttributeInteractionInfo); - Map writeBallastConfigurationMaxLevelCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationminLevelCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationMinLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeMinLevelAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationMinLevelCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeMinLevelAttribute", writeBallastConfigurationMinLevelAttributeInteractionInfo); + Map writeBallastConfigurationMaxLevelCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationmaxLevelCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBallastConfigurationMaxLevelCommandParams.put( - "value", ballastConfigurationmaxLevelCommandParameterInfo); - InteractionInfo writeBallastConfigurationMaxLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeMaxLevelAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationMaxLevelCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeMaxLevelAttribute", writeBallastConfigurationMaxLevelAttributeInteractionInfo); - Map writeBallastConfigurationIntrinsicBallastFactorCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationmaxLevelCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationMaxLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeMaxLevelAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationMaxLevelCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeMaxLevelAttribute", writeBallastConfigurationMaxLevelAttributeInteractionInfo); + Map writeBallastConfigurationIntrinsicBallastFactorCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationintrinsicBallastFactorCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBallastConfigurationIntrinsicBallastFactorCommandParams.put( - "value", ballastConfigurationintrinsicBallastFactorCommandParameterInfo); - InteractionInfo writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeIntrinsicBallastFactorAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationIntrinsicBallastFactorCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeIntrinsicBallastFactorAttribute", - writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); - Map - writeBallastConfigurationBallastFactorAdjustmentCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationintrinsicBallastFactorCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeIntrinsicBallastFactorAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationIntrinsicBallastFactorCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeIntrinsicBallastFactorAttribute", writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); + Map writeBallastConfigurationBallastFactorAdjustmentCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationballastFactorAdjustmentCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBallastConfigurationBallastFactorAdjustmentCommandParams.put( - "value", ballastConfigurationballastFactorAdjustmentCommandParameterInfo); - InteractionInfo writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeBallastFactorAdjustmentAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationBallastFactorAdjustmentCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeBallastFactorAdjustmentAttribute", - writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); - Map writeBallastConfigurationLampTypeCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationballastFactorAdjustmentCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeBallastFactorAdjustmentAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationBallastFactorAdjustmentCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeBallastFactorAdjustmentAttribute", writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); + Map writeBallastConfigurationLampTypeCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampTypeCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBallastConfigurationLampTypeCommandParams.put( - "value", ballastConfigurationlampTypeCommandParameterInfo); - InteractionInfo writeBallastConfigurationLampTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeLampTypeAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampTypeCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeLampTypeAttribute", writeBallastConfigurationLampTypeAttributeInteractionInfo); - Map writeBallastConfigurationLampManufacturerCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationlampTypeCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationLampTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeLampTypeAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampTypeCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeLampTypeAttribute", writeBallastConfigurationLampTypeAttributeInteractionInfo); + Map writeBallastConfigurationLampManufacturerCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampManufacturerCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeBallastConfigurationLampManufacturerCommandParams.put( - "value", ballastConfigurationlampManufacturerCommandParameterInfo); - InteractionInfo writeBallastConfigurationLampManufacturerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeLampManufacturerAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampManufacturerCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeLampManufacturerAttribute", - writeBallastConfigurationLampManufacturerAttributeInteractionInfo); - Map writeBallastConfigurationLampRatedHoursCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationlampManufacturerCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationLampManufacturerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeLampManufacturerAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampManufacturerCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeLampManufacturerAttribute", writeBallastConfigurationLampManufacturerAttributeInteractionInfo); + Map writeBallastConfigurationLampRatedHoursCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampRatedHoursCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeBallastConfigurationLampRatedHoursCommandParams.put( - "value", ballastConfigurationlampRatedHoursCommandParameterInfo); - InteractionInfo writeBallastConfigurationLampRatedHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeLampRatedHoursAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampRatedHoursCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeLampRatedHoursAttribute", - writeBallastConfigurationLampRatedHoursAttributeInteractionInfo); - Map writeBallastConfigurationLampBurnHoursCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationlampRatedHoursCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationLampRatedHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeLampRatedHoursAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampRatedHoursCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeLampRatedHoursAttribute", writeBallastConfigurationLampRatedHoursAttributeInteractionInfo); + Map writeBallastConfigurationLampBurnHoursCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampBurnHoursCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeBallastConfigurationLampBurnHoursCommandParams.put( - "value", ballastConfigurationlampBurnHoursCommandParameterInfo); - InteractionInfo writeBallastConfigurationLampBurnHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeLampBurnHoursAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampBurnHoursCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeLampBurnHoursAttribute", - writeBallastConfigurationLampBurnHoursAttributeInteractionInfo); - Map writeBallastConfigurationLampAlarmModeCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationlampBurnHoursCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationLampBurnHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeLampBurnHoursAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampBurnHoursCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeLampBurnHoursAttribute", writeBallastConfigurationLampBurnHoursAttributeInteractionInfo); + Map writeBallastConfigurationLampAlarmModeCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampAlarmModeCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeBallastConfigurationLampAlarmModeCommandParams.put( - "value", ballastConfigurationlampAlarmModeCommandParameterInfo); - InteractionInfo writeBallastConfigurationLampAlarmModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeLampAlarmModeAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampAlarmModeCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeLampAlarmModeAttribute", - writeBallastConfigurationLampAlarmModeAttributeInteractionInfo); - Map writeBallastConfigurationLampBurnHoursTripPointCommandParams = - new LinkedHashMap(); + "value", + ballastConfigurationlampAlarmModeCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationLampAlarmModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeLampAlarmModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampAlarmModeCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeLampAlarmModeAttribute", writeBallastConfigurationLampAlarmModeAttributeInteractionInfo); + Map writeBallastConfigurationLampBurnHoursTripPointCommandParams = new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampBurnHoursTripPointCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeBallastConfigurationLampBurnHoursTripPointCommandParams.put( - "value", ballastConfigurationlampBurnHoursTripPointCommandParameterInfo); - InteractionInfo writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster) - .writeLampBurnHoursTripPointAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampBurnHoursTripPointCommandParams); - writeBallastConfigurationInteractionInfo.put( - "writeLampBurnHoursTripPointAttribute", - writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); + "value", + ballastConfigurationlampBurnHoursTripPointCommandParameterInfo + ); + InteractionInfo writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster).writeLampBurnHoursTripPointAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampBurnHoursTripPointCommandParams + ); + writeBallastConfigurationInteractionInfo.put("writeLampBurnHoursTripPointAttribute", writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); writeAttributeMap.put("ballastConfiguration", writeBallastConfigurationInteractionInfo); Map writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); @@ -2307,198 +2832,207 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeRelativeHumidityMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map - writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = - new LinkedHashMap(); + Map writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); CommandParameterInfo occupancySensingPIROccupiedToUnoccupiedDelayCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams.put( - "value", occupancySensingPIROccupiedToUnoccupiedDelayCommandParameterInfo); - InteractionInfo writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writePIROccupiedToUnoccupiedDelayAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams); - writeOccupancySensingInteractionInfo.put( - "writePIROccupiedToUnoccupiedDelayAttribute", - writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map - writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = - new LinkedHashMap(); + "value", + occupancySensingPIROccupiedToUnoccupiedDelayCommandParameterInfo + ); + InteractionInfo writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writePIROccupiedToUnoccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams + ); + writeOccupancySensingInteractionInfo.put("writePIROccupiedToUnoccupiedDelayAttribute", writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); CommandParameterInfo occupancySensingPIRUnoccupiedToOccupiedDelayCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams.put( - "value", occupancySensingPIRUnoccupiedToOccupiedDelayCommandParameterInfo); - InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writePIRUnoccupiedToOccupiedDelayAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams); - writeOccupancySensingInteractionInfo.put( - "writePIRUnoccupiedToOccupiedDelayAttribute", - writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map - writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = - new LinkedHashMap(); + "value", + occupancySensingPIRUnoccupiedToOccupiedDelayCommandParameterInfo + ); + InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writePIRUnoccupiedToOccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams + ); + writeOccupancySensingInteractionInfo.put("writePIRUnoccupiedToOccupiedDelayAttribute", writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); CommandParameterInfo occupancySensingPIRUnoccupiedToOccupiedThresholdCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams.put( - "value", occupancySensingPIRUnoccupiedToOccupiedThresholdCommandParameterInfo); - InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writePIRUnoccupiedToOccupiedThresholdAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams); - writeOccupancySensingInteractionInfo.put( - "writePIRUnoccupiedToOccupiedThresholdAttribute", - writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map - writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = - new LinkedHashMap(); + "value", + occupancySensingPIRUnoccupiedToOccupiedThresholdCommandParameterInfo + ); + InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writePIRUnoccupiedToOccupiedThresholdAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams + ); + writeOccupancySensingInteractionInfo.put("writePIRUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); CommandParameterInfo occupancySensingultrasonicOccupiedToUnoccupiedDelayCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams.put( - "value", occupancySensingultrasonicOccupiedToUnoccupiedDelayCommandParameterInfo); - InteractionInfo - writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writeUltrasonicOccupiedToUnoccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams); - writeOccupancySensingInteractionInfo.put( - "writeUltrasonicOccupiedToUnoccupiedDelayAttribute", - writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map - writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = - new LinkedHashMap(); + "value", + occupancySensingultrasonicOccupiedToUnoccupiedDelayCommandParameterInfo + ); + InteractionInfo writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writeUltrasonicOccupiedToUnoccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams + ); + writeOccupancySensingInteractionInfo.put("writeUltrasonicOccupiedToUnoccupiedDelayAttribute", writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); CommandParameterInfo occupancySensingultrasonicUnoccupiedToOccupiedDelayCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams.put( - "value", occupancySensingultrasonicUnoccupiedToOccupiedDelayCommandParameterInfo); - InteractionInfo - writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writeUltrasonicUnoccupiedToOccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams); - writeOccupancySensingInteractionInfo.put( - "writeUltrasonicUnoccupiedToOccupiedDelayAttribute", - writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map - writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = - new LinkedHashMap(); - CommandParameterInfo - occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + "value", + occupancySensingultrasonicUnoccupiedToOccupiedDelayCommandParameterInfo + ); + InteractionInfo writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writeUltrasonicUnoccupiedToOccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams + ); + writeOccupancySensingInteractionInfo.put("writeUltrasonicUnoccupiedToOccupiedDelayAttribute", writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); + CommandParameterInfo occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams.put( - "value", occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo); - InteractionInfo - writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writeUltrasonicUnoccupiedToOccupiedThresholdAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams); - writeOccupancySensingInteractionInfo.put( - "writeUltrasonicUnoccupiedToOccupiedThresholdAttribute", - writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map - writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = - new LinkedHashMap(); - CommandParameterInfo - occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + "value", + occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo + ); + InteractionInfo writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writeUltrasonicUnoccupiedToOccupiedThresholdAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams + ); + writeOccupancySensingInteractionInfo.put("writeUltrasonicUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); + CommandParameterInfo occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams.put( - "value", occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo); - InteractionInfo - writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writePhysicalContactOccupiedToUnoccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams); - writeOccupancySensingInteractionInfo.put( - "writePhysicalContactOccupiedToUnoccupiedDelayAttribute", - writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = - new LinkedHashMap(); - CommandParameterInfo - occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + "value", + occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo + ); + InteractionInfo writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writePhysicalContactOccupiedToUnoccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams + ); + writeOccupancySensingInteractionInfo.put("writePhysicalContactOccupiedToUnoccupiedDelayAttribute", writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); + CommandParameterInfo occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams.put( - "value", occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo); - InteractionInfo - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writePhysicalContactUnoccupiedToOccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams); - writeOccupancySensingInteractionInfo.put( - "writePhysicalContactUnoccupiedToOccupiedDelayAttribute", - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = - new LinkedHashMap(); - CommandParameterInfo - occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + "value", + occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo + ); + InteractionInfo writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writePhysicalContactUnoccupiedToOccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams + ); + writeOccupancySensingInteractionInfo.put("writePhysicalContactUnoccupiedToOccupiedDelayAttribute", writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); + CommandParameterInfo occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams.put( - "value", occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo); - InteractionInfo - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .writePhysicalContactUnoccupiedToOccupiedThresholdAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams); - writeOccupancySensingInteractionInfo.put( - "writePhysicalContactUnoccupiedToOccupiedThresholdAttribute", - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + "value", + occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo + ); + InteractionInfo writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).writePhysicalContactUnoccupiedToOccupiedThresholdAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams + ); + writeOccupancySensingInteractionInfo.put("writePhysicalContactUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); @@ -2515,24 +3049,28 @@ public Map> getWriteAttributeMap() { Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = - new LinkedHashMap(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeContentLauncherSupportedStreamingProtocolsCommandParams.put( - "value", contentLaunchersupportedStreamingProtocolsCommandParameterInfo); - InteractionInfo writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .writeSupportedStreamingProtocolsAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeContentLauncherSupportedStreamingProtocolsCommandParams); - writeContentLauncherInteractionInfo.put( - "writeSupportedStreamingProtocolsAttribute", - writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + "value", + contentLaunchersupportedStreamingProtocolsCommandParameterInfo + ); + InteractionInfo writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).writeSupportedStreamingProtocolsAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeContentLauncherSupportedStreamingProtocolsCommandParams + ); + writeContentLauncherInteractionInfo.put("writeSupportedStreamingProtocolsAttribute", writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); @@ -2543,1411 +3081,1814 @@ public Map> getWriteAttributeMap() { Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map - writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = - new LinkedHashMap(); - CommandParameterInfo - electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + Map writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = new LinkedHashMap(); + CommandParameterInfo electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo = + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams.put( - "value", electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo); - InteractionInfo - writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeAverageRmsVoltageMeasurementPeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeAverageRmsVoltageMeasurementPeriodAttribute", - writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); - Map - writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeAverageRmsVoltageMeasurementPeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeAverageRmsVoltageMeasurementPeriodAttribute", writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); + Map writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementaverageRmsUnderVoltageCounterCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams.put( - "value", electricalMeasurementaverageRmsUnderVoltageCounterCommandParameterInfo); - InteractionInfo - writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeAverageRmsUnderVoltageCounterAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeAverageRmsUnderVoltageCounterAttribute", - writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); - Map - writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementaverageRmsUnderVoltageCounterCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeAverageRmsUnderVoltageCounterAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeAverageRmsUnderVoltageCounterAttribute", writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); + Map writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsExtremeOverVoltagePeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams.put( - "value", electricalMeasurementrmsExtremeOverVoltagePeriodCommandParameterInfo); - InteractionInfo writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeRmsExtremeOverVoltagePeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeRmsExtremeOverVoltagePeriodAttribute", - writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); - Map - writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementrmsExtremeOverVoltagePeriodCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsExtremeOverVoltagePeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeRmsExtremeOverVoltagePeriodAttribute", writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); + Map writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsExtremeUnderVoltagePeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams.put( - "value", electricalMeasurementrmsExtremeUnderVoltagePeriodCommandParameterInfo); - InteractionInfo writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeRmsExtremeUnderVoltagePeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeRmsExtremeUnderVoltagePeriodAttribute", - writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); - Map writeElectricalMeasurementRmsVoltageSagPeriodCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementrmsExtremeUnderVoltagePeriodCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsExtremeUnderVoltagePeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeRmsExtremeUnderVoltagePeriodAttribute", writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); + Map writeElectricalMeasurementRmsVoltageSagPeriodCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsVoltageSagPeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementRmsVoltageSagPeriodCommandParams.put( - "value", electricalMeasurementrmsVoltageSagPeriodCommandParameterInfo); - InteractionInfo writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeRmsVoltageSagPeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsVoltageSagPeriodCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeRmsVoltageSagPeriodAttribute", - writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); - Map writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementrmsVoltageSagPeriodCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsVoltageSagPeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsVoltageSagPeriodCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeRmsVoltageSagPeriodAttribute", writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); + Map writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsVoltageSwellPeriodCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams.put( - "value", electricalMeasurementrmsVoltageSwellPeriodCommandParameterInfo); - InteractionInfo writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeRmsVoltageSwellPeriodAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeRmsVoltageSwellPeriodAttribute", - writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); - Map writeElectricalMeasurementOverloadAlarmsMaskCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementrmsVoltageSwellPeriodCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsVoltageSwellPeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeRmsVoltageSwellPeriodAttribute", writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); + Map writeElectricalMeasurementOverloadAlarmsMaskCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementoverloadAlarmsMaskCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementOverloadAlarmsMaskCommandParams.put( - "value", electricalMeasurementoverloadAlarmsMaskCommandParameterInfo); - InteractionInfo writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeOverloadAlarmsMaskAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementOverloadAlarmsMaskCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeOverloadAlarmsMaskAttribute", - writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); - Map writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams = - new LinkedHashMap(); + "value", + electricalMeasurementoverloadAlarmsMaskCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeOverloadAlarmsMaskAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementOverloadAlarmsMaskCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeOverloadAlarmsMaskAttribute", writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); + Map writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams = new LinkedHashMap(); CommandParameterInfo electricalMeasurementacOverloadAlarmsMaskCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams.put( - "value", electricalMeasurementacOverloadAlarmsMaskCommandParameterInfo); - InteractionInfo writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .writeAcOverloadAlarmsMaskAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams); - writeElectricalMeasurementInteractionInfo.put( - "writeAcOverloadAlarmsMaskAttribute", - writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); + "value", + electricalMeasurementacOverloadAlarmsMaskCommandParameterInfo + ); + InteractionInfo writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).writeAcOverloadAlarmsMaskAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams + ); + writeElectricalMeasurementInteractionInfo.put("writeAcOverloadAlarmsMaskAttribute", writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); Map writeUnitTestingInteractionInfo = new LinkedHashMap<>(); - Map writeUnitTestingBooleanCommandParams = - new LinkedHashMap(); + Map writeUnitTestingBooleanCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingbooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); - writeUnitTestingBooleanCommandParams.put("value", unitTestingbooleanCommandParameterInfo); - InteractionInfo writeUnitTestingBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBooleanCommandParams); - writeUnitTestingInteractionInfo.put( - "writeBooleanAttribute", writeUnitTestingBooleanAttributeInteractionInfo); - Map writeUnitTestingBitmap8CommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); + writeUnitTestingBooleanCommandParams.put( + "value", + unitTestingbooleanCommandParameterInfo + ); + InteractionInfo writeUnitTestingBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBooleanCommandParams + ); + writeUnitTestingInteractionInfo.put("writeBooleanAttribute", writeUnitTestingBooleanAttributeInteractionInfo); + Map writeUnitTestingBitmap8CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingbitmap8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingBitmap8CommandParams.put("value", unitTestingbitmap8CommandParameterInfo); - InteractionInfo writeUnitTestingBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeBitmap8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap8CommandParams); - writeUnitTestingInteractionInfo.put( - "writeBitmap8Attribute", writeUnitTestingBitmap8AttributeInteractionInfo); - Map writeUnitTestingBitmap16CommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingBitmap8CommandParams.put( + "value", + unitTestingbitmap8CommandParameterInfo + ); + InteractionInfo writeUnitTestingBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeBitmap8Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap8CommandParams + ); + writeUnitTestingInteractionInfo.put("writeBitmap8Attribute", writeUnitTestingBitmap8AttributeInteractionInfo); + Map writeUnitTestingBitmap16CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingbitmap16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingBitmap16CommandParams.put("value", unitTestingbitmap16CommandParameterInfo); - InteractionInfo writeUnitTestingBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeBitmap16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap16CommandParams); - writeUnitTestingInteractionInfo.put( - "writeBitmap16Attribute", writeUnitTestingBitmap16AttributeInteractionInfo); - Map writeUnitTestingBitmap32CommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingBitmap16CommandParams.put( + "value", + unitTestingbitmap16CommandParameterInfo + ); + InteractionInfo writeUnitTestingBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeBitmap16Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap16CommandParams + ); + writeUnitTestingInteractionInfo.put("writeBitmap16Attribute", writeUnitTestingBitmap16AttributeInteractionInfo); + Map writeUnitTestingBitmap32CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingbitmap32CommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingBitmap32CommandParams.put("value", unitTestingbitmap32CommandParameterInfo); - InteractionInfo writeUnitTestingBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeBitmap32Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap32CommandParams); - writeUnitTestingInteractionInfo.put( - "writeBitmap32Attribute", writeUnitTestingBitmap32AttributeInteractionInfo); - Map writeUnitTestingBitmap64CommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingBitmap32CommandParams.put( + "value", + unitTestingbitmap32CommandParameterInfo + ); + InteractionInfo writeUnitTestingBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeBitmap32Attribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap32CommandParams + ); + writeUnitTestingInteractionInfo.put("writeBitmap32Attribute", writeUnitTestingBitmap32AttributeInteractionInfo); + Map writeUnitTestingBitmap64CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingbitmap64CommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingBitmap64CommandParams.put("value", unitTestingbitmap64CommandParameterInfo); - InteractionInfo writeUnitTestingBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeBitmap64Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap64CommandParams); - writeUnitTestingInteractionInfo.put( - "writeBitmap64Attribute", writeUnitTestingBitmap64AttributeInteractionInfo); - Map writeUnitTestingInt8uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingBitmap64CommandParams.put( + "value", + unitTestingbitmap64CommandParameterInfo + ); + InteractionInfo writeUnitTestingBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeBitmap64Attribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap64CommandParams + ); + writeUnitTestingInteractionInfo.put("writeBitmap64Attribute", writeUnitTestingBitmap64AttributeInteractionInfo); + Map writeUnitTestingInt8uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingInt8uCommandParams.put("value", unitTestingint8uCommandParameterInfo); - InteractionInfo writeUnitTestingInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt8uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt8uAttribute", writeUnitTestingInt8uAttributeInteractionInfo); - Map writeUnitTestingInt16uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingInt8uCommandParams.put( + "value", + unitTestingint8uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt8uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt8uAttribute", writeUnitTestingInt8uAttributeInteractionInfo); + Map writeUnitTestingInt16uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingInt16uCommandParams.put("value", unitTestingint16uCommandParameterInfo); - InteractionInfo writeUnitTestingInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt16uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt16uAttribute", writeUnitTestingInt16uAttributeInteractionInfo); - Map writeUnitTestingInt24uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingInt16uCommandParams.put( + "value", + unitTestingint16uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt16uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt16uAttribute", writeUnitTestingInt16uAttributeInteractionInfo); + Map writeUnitTestingInt24uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint24uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt24uCommandParams.put("value", unitTestingint24uCommandParameterInfo); - InteractionInfo writeUnitTestingInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt24uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt24uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt24uAttribute", writeUnitTestingInt24uAttributeInteractionInfo); - Map writeUnitTestingInt32uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt24uCommandParams.put( + "value", + unitTestingint24uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt24uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt24uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt24uAttribute", writeUnitTestingInt24uAttributeInteractionInfo); + Map writeUnitTestingInt32uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint32uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt32uCommandParams.put("value", unitTestingint32uCommandParameterInfo); - InteractionInfo writeUnitTestingInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt32uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt32uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt32uAttribute", writeUnitTestingInt32uAttributeInteractionInfo); - Map writeUnitTestingInt40uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt32uCommandParams.put( + "value", + unitTestingint32uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt32uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt32uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt32uAttribute", writeUnitTestingInt32uAttributeInteractionInfo); + Map writeUnitTestingInt40uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint40uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt40uCommandParams.put("value", unitTestingint40uCommandParameterInfo); - InteractionInfo writeUnitTestingInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt40uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt40uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt40uAttribute", writeUnitTestingInt40uAttributeInteractionInfo); - Map writeUnitTestingInt48uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt40uCommandParams.put( + "value", + unitTestingint40uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt40uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt40uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt40uAttribute", writeUnitTestingInt40uAttributeInteractionInfo); + Map writeUnitTestingInt48uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint48uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt48uCommandParams.put("value", unitTestingint48uCommandParameterInfo); - InteractionInfo writeUnitTestingInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt48uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt48uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt48uAttribute", writeUnitTestingInt48uAttributeInteractionInfo); - Map writeUnitTestingInt56uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt48uCommandParams.put( + "value", + unitTestingint48uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt48uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt48uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt48uAttribute", writeUnitTestingInt48uAttributeInteractionInfo); + Map writeUnitTestingInt56uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint56uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt56uCommandParams.put("value", unitTestingint56uCommandParameterInfo); - InteractionInfo writeUnitTestingInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt56uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt56uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt56uAttribute", writeUnitTestingInt56uAttributeInteractionInfo); - Map writeUnitTestingInt64uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt56uCommandParams.put( + "value", + unitTestingint56uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt56uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt56uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt56uAttribute", writeUnitTestingInt56uAttributeInteractionInfo); + Map writeUnitTestingInt64uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint64uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt64uCommandParams.put("value", unitTestingint64uCommandParameterInfo); - InteractionInfo writeUnitTestingInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt64uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt64uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt64uAttribute", writeUnitTestingInt64uAttributeInteractionInfo); - Map writeUnitTestingInt8sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt64uCommandParams.put( + "value", + unitTestingint64uCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt64uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt64uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt64uAttribute", writeUnitTestingInt64uAttributeInteractionInfo); + Map writeUnitTestingInt8sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingInt8sCommandParams.put("value", unitTestingint8sCommandParameterInfo); - InteractionInfo writeUnitTestingInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt8sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt8sAttribute", writeUnitTestingInt8sAttributeInteractionInfo); - Map writeUnitTestingInt16sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingInt8sCommandParams.put( + "value", + unitTestingint8sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt8sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt8sAttribute", writeUnitTestingInt8sAttributeInteractionInfo); + Map writeUnitTestingInt16sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingInt16sCommandParams.put("value", unitTestingint16sCommandParameterInfo); - InteractionInfo writeUnitTestingInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt16sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt16sAttribute", writeUnitTestingInt16sAttributeInteractionInfo); - Map writeUnitTestingInt24sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingInt16sCommandParams.put( + "value", + unitTestingint16sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt16sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt16sAttribute", writeUnitTestingInt16sAttributeInteractionInfo); + Map writeUnitTestingInt24sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint24sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt24sCommandParams.put("value", unitTestingint24sCommandParameterInfo); - InteractionInfo writeUnitTestingInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt24sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt24sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt24sAttribute", writeUnitTestingInt24sAttributeInteractionInfo); - Map writeUnitTestingInt32sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt24sCommandParams.put( + "value", + unitTestingint24sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt24sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt24sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt24sAttribute", writeUnitTestingInt24sAttributeInteractionInfo); + Map writeUnitTestingInt32sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint32sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt32sCommandParams.put("value", unitTestingint32sCommandParameterInfo); - InteractionInfo writeUnitTestingInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt32sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt32sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt32sAttribute", writeUnitTestingInt32sAttributeInteractionInfo); - Map writeUnitTestingInt40sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt32sCommandParams.put( + "value", + unitTestingint32sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt32sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt32sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt32sAttribute", writeUnitTestingInt32sAttributeInteractionInfo); + Map writeUnitTestingInt40sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint40sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt40sCommandParams.put("value", unitTestingint40sCommandParameterInfo); - InteractionInfo writeUnitTestingInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt40sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt40sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt40sAttribute", writeUnitTestingInt40sAttributeInteractionInfo); - Map writeUnitTestingInt48sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt40sCommandParams.put( + "value", + unitTestingint40sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt40sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt40sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt40sAttribute", writeUnitTestingInt40sAttributeInteractionInfo); + Map writeUnitTestingInt48sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint48sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt48sCommandParams.put("value", unitTestingint48sCommandParameterInfo); - InteractionInfo writeUnitTestingInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt48sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt48sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt48sAttribute", writeUnitTestingInt48sAttributeInteractionInfo); - Map writeUnitTestingInt56sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt48sCommandParams.put( + "value", + unitTestingint48sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt48sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt48sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt48sAttribute", writeUnitTestingInt48sAttributeInteractionInfo); + Map writeUnitTestingInt56sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint56sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt56sCommandParams.put("value", unitTestingint56sCommandParameterInfo); - InteractionInfo writeUnitTestingInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt56sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt56sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt56sAttribute", writeUnitTestingInt56sAttributeInteractionInfo); - Map writeUnitTestingInt64sCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt56sCommandParams.put( + "value", + unitTestingint56sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt56sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt56sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt56sAttribute", writeUnitTestingInt56sAttributeInteractionInfo); + Map writeUnitTestingInt64sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingint64sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingInt64sCommandParams.put("value", unitTestingint64sCommandParameterInfo); - InteractionInfo writeUnitTestingInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeInt64sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt64sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeInt64sAttribute", writeUnitTestingInt64sAttributeInteractionInfo); - Map writeUnitTestingEnum8CommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingInt64sCommandParams.put( + "value", + unitTestingint64sCommandParameterInfo + ); + InteractionInfo writeUnitTestingInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeInt64sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt64sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeInt64sAttribute", writeUnitTestingInt64sAttributeInteractionInfo); + Map writeUnitTestingEnum8CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingenum8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingEnum8CommandParams.put("value", unitTestingenum8CommandParameterInfo); - InteractionInfo writeUnitTestingEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeEnum8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEnum8CommandParams); - writeUnitTestingInteractionInfo.put( - "writeEnum8Attribute", writeUnitTestingEnum8AttributeInteractionInfo); - Map writeUnitTestingEnum16CommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingEnum8CommandParams.put( + "value", + unitTestingenum8CommandParameterInfo + ); + InteractionInfo writeUnitTestingEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeEnum8Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEnum8CommandParams + ); + writeUnitTestingInteractionInfo.put("writeEnum8Attribute", writeUnitTestingEnum8AttributeInteractionInfo); + Map writeUnitTestingEnum16CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingenum16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingEnum16CommandParams.put("value", unitTestingenum16CommandParameterInfo); - InteractionInfo writeUnitTestingEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeEnum16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEnum16CommandParams); - writeUnitTestingInteractionInfo.put( - "writeEnum16Attribute", writeUnitTestingEnum16AttributeInteractionInfo); - Map writeUnitTestingFloatSingleCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingEnum16CommandParams.put( + "value", + unitTestingenum16CommandParameterInfo + ); + InteractionInfo writeUnitTestingEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeEnum16Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEnum16CommandParams + ); + writeUnitTestingInteractionInfo.put("writeEnum16Attribute", writeUnitTestingEnum16AttributeInteractionInfo); + Map writeUnitTestingFloatSingleCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingfloatSingleCommandParameterInfo = - new CommandParameterInfo("value", Float.class, Float.class); + new CommandParameterInfo( + "value", + Float.class, + Float.class + ); writeUnitTestingFloatSingleCommandParams.put( - "value", unitTestingfloatSingleCommandParameterInfo); - InteractionInfo writeUnitTestingFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeFloatSingleAttribute( - (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingFloatSingleCommandParams); - writeUnitTestingInteractionInfo.put( - "writeFloatSingleAttribute", writeUnitTestingFloatSingleAttributeInteractionInfo); - Map writeUnitTestingFloatDoubleCommandParams = - new LinkedHashMap(); + "value", + unitTestingfloatSingleCommandParameterInfo + ); + InteractionInfo writeUnitTestingFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeFloatSingleAttribute( + (DefaultClusterCallback) callback, + (Float) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingFloatSingleCommandParams + ); + writeUnitTestingInteractionInfo.put("writeFloatSingleAttribute", writeUnitTestingFloatSingleAttributeInteractionInfo); + Map writeUnitTestingFloatDoubleCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingfloatDoubleCommandParameterInfo = - new CommandParameterInfo("value", Double.class, Double.class); + new CommandParameterInfo( + "value", + Double.class, + Double.class + ); writeUnitTestingFloatDoubleCommandParams.put( - "value", unitTestingfloatDoubleCommandParameterInfo); - InteractionInfo writeUnitTestingFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingFloatDoubleCommandParams); - writeUnitTestingInteractionInfo.put( - "writeFloatDoubleAttribute", writeUnitTestingFloatDoubleAttributeInteractionInfo); - Map writeUnitTestingOctetStringCommandParams = - new LinkedHashMap(); + "value", + unitTestingfloatDoubleCommandParameterInfo + ); + InteractionInfo writeUnitTestingFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, + (Double) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingFloatDoubleCommandParams + ); + writeUnitTestingInteractionInfo.put("writeFloatDoubleAttribute", writeUnitTestingFloatDoubleAttributeInteractionInfo); + Map writeUnitTestingOctetStringCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingoctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class, byte[].class); + new CommandParameterInfo( + "value", + byte[].class, + byte[].class + ); writeUnitTestingOctetStringCommandParams.put( - "value", unitTestingoctetStringCommandParameterInfo); - InteractionInfo writeUnitTestingOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingOctetStringCommandParams); - writeUnitTestingInteractionInfo.put( - "writeOctetStringAttribute", writeUnitTestingOctetStringAttributeInteractionInfo); - Map writeUnitTestingLongOctetStringCommandParams = - new LinkedHashMap(); + "value", + unitTestingoctetStringCommandParameterInfo + ); + InteractionInfo writeUnitTestingOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingOctetStringCommandParams + ); + writeUnitTestingInteractionInfo.put("writeOctetStringAttribute", writeUnitTestingOctetStringAttributeInteractionInfo); + Map writeUnitTestingLongOctetStringCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestinglongOctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class, byte[].class); + new CommandParameterInfo( + "value", + byte[].class, + byte[].class + ); writeUnitTestingLongOctetStringCommandParams.put( - "value", unitTestinglongOctetStringCommandParameterInfo); - InteractionInfo writeUnitTestingLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingLongOctetStringCommandParams); - writeUnitTestingInteractionInfo.put( - "writeLongOctetStringAttribute", writeUnitTestingLongOctetStringAttributeInteractionInfo); - Map writeUnitTestingCharStringCommandParams = - new LinkedHashMap(); + "value", + unitTestinglongOctetStringCommandParameterInfo + ); + InteractionInfo writeUnitTestingLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingLongOctetStringCommandParams + ); + writeUnitTestingInteractionInfo.put("writeLongOctetStringAttribute", writeUnitTestingLongOctetStringAttributeInteractionInfo); + Map writeUnitTestingCharStringCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingcharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); - writeUnitTestingCharStringCommandParams.put("value", unitTestingcharStringCommandParameterInfo); - InteractionInfo writeUnitTestingCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingCharStringCommandParams); - writeUnitTestingInteractionInfo.put( - "writeCharStringAttribute", writeUnitTestingCharStringAttributeInteractionInfo); - Map writeUnitTestingLongCharStringCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + String.class, + String.class + ); + writeUnitTestingCharStringCommandParams.put( + "value", + unitTestingcharStringCommandParameterInfo + ); + InteractionInfo writeUnitTestingCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeCharStringAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingCharStringCommandParams + ); + writeUnitTestingInteractionInfo.put("writeCharStringAttribute", writeUnitTestingCharStringAttributeInteractionInfo); + Map writeUnitTestingLongCharStringCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestinglongCharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeUnitTestingLongCharStringCommandParams.put( - "value", unitTestinglongCharStringCommandParameterInfo); - InteractionInfo writeUnitTestingLongCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeLongCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingLongCharStringCommandParams); - writeUnitTestingInteractionInfo.put( - "writeLongCharStringAttribute", writeUnitTestingLongCharStringAttributeInteractionInfo); - Map writeUnitTestingEpochUsCommandParams = - new LinkedHashMap(); + "value", + unitTestinglongCharStringCommandParameterInfo + ); + InteractionInfo writeUnitTestingLongCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeLongCharStringAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingLongCharStringCommandParams + ); + writeUnitTestingInteractionInfo.put("writeLongCharStringAttribute", writeUnitTestingLongCharStringAttributeInteractionInfo); + Map writeUnitTestingEpochUsCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingepochUsCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingEpochUsCommandParams.put("value", unitTestingepochUsCommandParameterInfo); - InteractionInfo writeUnitTestingEpochUsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeEpochUsAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEpochUsCommandParams); - writeUnitTestingInteractionInfo.put( - "writeEpochUsAttribute", writeUnitTestingEpochUsAttributeInteractionInfo); - Map writeUnitTestingEpochSCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingEpochUsCommandParams.put( + "value", + unitTestingepochUsCommandParameterInfo + ); + InteractionInfo writeUnitTestingEpochUsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeEpochUsAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEpochUsCommandParams + ); + writeUnitTestingInteractionInfo.put("writeEpochUsAttribute", writeUnitTestingEpochUsAttributeInteractionInfo); + Map writeUnitTestingEpochSCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingepochSCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); - writeUnitTestingEpochSCommandParams.put("value", unitTestingepochSCommandParameterInfo); - InteractionInfo writeUnitTestingEpochSAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeEpochSAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEpochSCommandParams); - writeUnitTestingInteractionInfo.put( - "writeEpochSAttribute", writeUnitTestingEpochSAttributeInteractionInfo); - Map writeUnitTestingVendorIdCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); + writeUnitTestingEpochSCommandParams.put( + "value", + unitTestingepochSCommandParameterInfo + ); + InteractionInfo writeUnitTestingEpochSAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeEpochSAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEpochSCommandParams + ); + writeUnitTestingInteractionInfo.put("writeEpochSAttribute", writeUnitTestingEpochSAttributeInteractionInfo); + Map writeUnitTestingVendorIdCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingvendorIdCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingVendorIdCommandParams.put("value", unitTestingvendorIdCommandParameterInfo); - InteractionInfo writeUnitTestingVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeVendorIdAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingVendorIdCommandParams); - writeUnitTestingInteractionInfo.put( - "writeVendorIdAttribute", writeUnitTestingVendorIdAttributeInteractionInfo); - Map writeUnitTestingEnumAttrCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingVendorIdCommandParams.put( + "value", + unitTestingvendorIdCommandParameterInfo + ); + InteractionInfo writeUnitTestingVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeVendorIdAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingVendorIdCommandParams + ); + writeUnitTestingInteractionInfo.put("writeVendorIdAttribute", writeUnitTestingVendorIdAttributeInteractionInfo); + Map writeUnitTestingEnumAttrCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingenumAttrCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); - writeUnitTestingEnumAttrCommandParams.put("value", unitTestingenumAttrCommandParameterInfo); - InteractionInfo writeUnitTestingEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeEnumAttrAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEnumAttrCommandParams); - writeUnitTestingInteractionInfo.put( - "writeEnumAttrAttribute", writeUnitTestingEnumAttrAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); + writeUnitTestingEnumAttrCommandParams.put( + "value", + unitTestingenumAttrCommandParameterInfo + ); + InteractionInfo writeUnitTestingEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeEnumAttrAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEnumAttrCommandParams + ); + writeUnitTestingInteractionInfo.put("writeEnumAttrAttribute", writeUnitTestingEnumAttrAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt8uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingRangeRestrictedInt8uCommandParams.put( - "value", unitTestingrangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt8uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeRangeRestrictedInt8uAttribute", - writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); + "value", + unitTestingrangeRestrictedInt8uCommandParameterInfo + ); + InteractionInfo writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt8uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt8sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingRangeRestrictedInt8sCommandParams.put( - "value", unitTestingrangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt8sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeRangeRestrictedInt8sAttribute", - writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); + "value", + unitTestingrangeRestrictedInt8sCommandParameterInfo + ); + InteractionInfo writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt8sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt16uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingRangeRestrictedInt16uCommandParams.put( - "value", unitTestingrangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt16uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeRangeRestrictedInt16uAttribute", - writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); + "value", + unitTestingrangeRestrictedInt16uCommandParameterInfo + ); + InteractionInfo writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt16uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt16sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingRangeRestrictedInt16sCommandParams.put( - "value", unitTestingrangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt16sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeRangeRestrictedInt16sAttribute", - writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); - Map writeUnitTestingTimedWriteBooleanCommandParams = - new LinkedHashMap(); + "value", + unitTestingrangeRestrictedInt16sCommandParameterInfo + ); + InteractionInfo writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt16sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); + Map writeUnitTestingTimedWriteBooleanCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingtimedWriteBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeUnitTestingTimedWriteBooleanCommandParams.put( - "value", unitTestingtimedWriteBooleanCommandParameterInfo); - InteractionInfo writeUnitTestingTimedWriteBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value"), - 10000); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingTimedWriteBooleanCommandParams); - writeUnitTestingInteractionInfo.put( - "writeTimedWriteBooleanAttribute", - writeUnitTestingTimedWriteBooleanAttributeInteractionInfo); - Map writeUnitTestingGeneralErrorBooleanCommandParams = - new LinkedHashMap(); + "value", + unitTestingtimedWriteBooleanCommandParameterInfo + ); + InteractionInfo writeUnitTestingTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value"), 10000 + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingTimedWriteBooleanCommandParams + ); + writeUnitTestingInteractionInfo.put("writeTimedWriteBooleanAttribute", writeUnitTestingTimedWriteBooleanAttributeInteractionInfo); + Map writeUnitTestingGeneralErrorBooleanCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestinggeneralErrorBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeUnitTestingGeneralErrorBooleanCommandParams.put( - "value", unitTestinggeneralErrorBooleanCommandParameterInfo); - InteractionInfo writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingGeneralErrorBooleanCommandParams); - writeUnitTestingInteractionInfo.put( - "writeGeneralErrorBooleanAttribute", - writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo); - Map writeUnitTestingClusterErrorBooleanCommandParams = - new LinkedHashMap(); + "value", + unitTestinggeneralErrorBooleanCommandParameterInfo + ); + InteractionInfo writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingGeneralErrorBooleanCommandParams + ); + writeUnitTestingInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo); + Map writeUnitTestingClusterErrorBooleanCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingclusterErrorBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeUnitTestingClusterErrorBooleanCommandParams.put( - "value", unitTestingclusterErrorBooleanCommandParameterInfo); - InteractionInfo writeUnitTestingClusterErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingClusterErrorBooleanCommandParams); - writeUnitTestingInteractionInfo.put( - "writeClusterErrorBooleanAttribute", - writeUnitTestingClusterErrorBooleanAttributeInteractionInfo); - Map writeUnitTestingUnsupportedCommandParams = - new LinkedHashMap(); + "value", + unitTestingclusterErrorBooleanCommandParameterInfo + ); + InteractionInfo writeUnitTestingClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingClusterErrorBooleanCommandParams + ); + writeUnitTestingInteractionInfo.put("writeClusterErrorBooleanAttribute", writeUnitTestingClusterErrorBooleanAttributeInteractionInfo); + Map writeUnitTestingUnsupportedCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingunsupportedCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeUnitTestingUnsupportedCommandParams.put( - "value", unitTestingunsupportedCommandParameterInfo); - InteractionInfo writeUnitTestingUnsupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeUnsupportedAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingUnsupportedCommandParams); - writeUnitTestingInteractionInfo.put( - "writeUnsupportedAttribute", writeUnitTestingUnsupportedAttributeInteractionInfo); - Map writeUnitTestingNullableBooleanCommandParams = - new LinkedHashMap(); + "value", + unitTestingunsupportedCommandParameterInfo + ); + InteractionInfo writeUnitTestingUnsupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeUnsupportedAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingUnsupportedCommandParams + ); + writeUnitTestingInteractionInfo.put("writeUnsupportedAttribute", writeUnitTestingUnsupportedAttributeInteractionInfo); + Map writeUnitTestingNullableBooleanCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class, Boolean.class); + new CommandParameterInfo( + "value", + Boolean.class, + Boolean.class + ); writeUnitTestingNullableBooleanCommandParams.put( - "value", unitTestingnullableBooleanCommandParameterInfo); - InteractionInfo writeUnitTestingNullableBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBooleanCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableBooleanAttribute", writeUnitTestingNullableBooleanAttributeInteractionInfo); - Map writeUnitTestingNullableBitmap8CommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableBooleanCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBooleanCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableBooleanAttribute", writeUnitTestingNullableBooleanAttributeInteractionInfo); + Map writeUnitTestingNullableBitmap8CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableBitmap8CommandParams.put( - "value", unitTestingnullableBitmap8CommandParameterInfo); - InteractionInfo writeUnitTestingNullableBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap8CommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableBitmap8Attribute", writeUnitTestingNullableBitmap8AttributeInteractionInfo); - Map writeUnitTestingNullableBitmap16CommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableBitmap8CommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap8CommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableBitmap8Attribute", writeUnitTestingNullableBitmap8AttributeInteractionInfo); + Map writeUnitTestingNullableBitmap16CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableBitmap16CommandParams.put( - "value", unitTestingnullableBitmap16CommandParameterInfo); - InteractionInfo writeUnitTestingNullableBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap16CommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableBitmap16Attribute", writeUnitTestingNullableBitmap16AttributeInteractionInfo); - Map writeUnitTestingNullableBitmap32CommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableBitmap16CommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap16CommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableBitmap16Attribute", writeUnitTestingNullableBitmap16AttributeInteractionInfo); + Map writeUnitTestingNullableBitmap32CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap32CommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableBitmap32CommandParams.put( - "value", unitTestingnullableBitmap32CommandParameterInfo); - InteractionInfo writeUnitTestingNullableBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap32CommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableBitmap32Attribute", writeUnitTestingNullableBitmap32AttributeInteractionInfo); - Map writeUnitTestingNullableBitmap64CommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableBitmap32CommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap32CommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableBitmap32Attribute", writeUnitTestingNullableBitmap32AttributeInteractionInfo); + Map writeUnitTestingNullableBitmap64CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap64CommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableBitmap64CommandParams.put( - "value", unitTestingnullableBitmap64CommandParameterInfo); - InteractionInfo writeUnitTestingNullableBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap64CommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableBitmap64Attribute", writeUnitTestingNullableBitmap64AttributeInteractionInfo); - Map writeUnitTestingNullableInt8uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableBitmap64CommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap64CommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableBitmap64Attribute", writeUnitTestingNullableBitmap64AttributeInteractionInfo); + Map writeUnitTestingNullableInt8uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableInt8uCommandParams.put( - "value", unitTestingnullableInt8uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt8uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt8uAttribute", writeUnitTestingNullableInt8uAttributeInteractionInfo); - Map writeUnitTestingNullableInt16uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt8uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt8uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt8uAttribute", writeUnitTestingNullableInt8uAttributeInteractionInfo); + Map writeUnitTestingNullableInt16uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableInt16uCommandParams.put( - "value", unitTestingnullableInt16uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt16uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt16uAttribute", writeUnitTestingNullableInt16uAttributeInteractionInfo); - Map writeUnitTestingNullableInt24uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt16uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt16uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt16uAttribute", writeUnitTestingNullableInt16uAttributeInteractionInfo); + Map writeUnitTestingNullableInt24uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt24uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt24uCommandParams.put( - "value", unitTestingnullableInt24uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt24uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt24uAttribute", writeUnitTestingNullableInt24uAttributeInteractionInfo); - Map writeUnitTestingNullableInt32uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt24uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt24uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt24uAttribute", writeUnitTestingNullableInt24uAttributeInteractionInfo); + Map writeUnitTestingNullableInt32uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt32uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt32uCommandParams.put( - "value", unitTestingnullableInt32uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt32uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt32uAttribute", writeUnitTestingNullableInt32uAttributeInteractionInfo); - Map writeUnitTestingNullableInt40uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt32uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt32uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt32uAttribute", writeUnitTestingNullableInt32uAttributeInteractionInfo); + Map writeUnitTestingNullableInt40uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt40uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt40uCommandParams.put( - "value", unitTestingnullableInt40uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt40uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt40uAttribute", writeUnitTestingNullableInt40uAttributeInteractionInfo); - Map writeUnitTestingNullableInt48uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt40uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt40uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt40uAttribute", writeUnitTestingNullableInt40uAttributeInteractionInfo); + Map writeUnitTestingNullableInt48uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt48uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt48uCommandParams.put( - "value", unitTestingnullableInt48uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt48uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt48uAttribute", writeUnitTestingNullableInt48uAttributeInteractionInfo); - Map writeUnitTestingNullableInt56uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt48uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt48uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt48uAttribute", writeUnitTestingNullableInt48uAttributeInteractionInfo); + Map writeUnitTestingNullableInt56uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt56uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt56uCommandParams.put( - "value", unitTestingnullableInt56uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt56uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt56uAttribute", writeUnitTestingNullableInt56uAttributeInteractionInfo); - Map writeUnitTestingNullableInt64uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt56uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt56uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt56uAttribute", writeUnitTestingNullableInt56uAttributeInteractionInfo); + Map writeUnitTestingNullableInt64uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt64uCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt64uCommandParams.put( - "value", unitTestingnullableInt64uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt64uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt64uAttribute", writeUnitTestingNullableInt64uAttributeInteractionInfo); - Map writeUnitTestingNullableInt8sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt64uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt64uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt64uAttribute", writeUnitTestingNullableInt64uAttributeInteractionInfo); + Map writeUnitTestingNullableInt8sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableInt8sCommandParams.put( - "value", unitTestingnullableInt8sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt8sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt8sAttribute", writeUnitTestingNullableInt8sAttributeInteractionInfo); - Map writeUnitTestingNullableInt16sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt8sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt8sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt8sAttribute", writeUnitTestingNullableInt8sAttributeInteractionInfo); + Map writeUnitTestingNullableInt16sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableInt16sCommandParams.put( - "value", unitTestingnullableInt16sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt16sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt16sAttribute", writeUnitTestingNullableInt16sAttributeInteractionInfo); - Map writeUnitTestingNullableInt24sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt16sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt16sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt16sAttribute", writeUnitTestingNullableInt16sAttributeInteractionInfo); + Map writeUnitTestingNullableInt24sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt24sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt24sCommandParams.put( - "value", unitTestingnullableInt24sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt24sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt24sAttribute", writeUnitTestingNullableInt24sAttributeInteractionInfo); - Map writeUnitTestingNullableInt32sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt24sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt24sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt24sAttribute", writeUnitTestingNullableInt24sAttributeInteractionInfo); + Map writeUnitTestingNullableInt32sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt32sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt32sCommandParams.put( - "value", unitTestingnullableInt32sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt32sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt32sAttribute", writeUnitTestingNullableInt32sAttributeInteractionInfo); - Map writeUnitTestingNullableInt40sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt32sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt32sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt32sAttribute", writeUnitTestingNullableInt32sAttributeInteractionInfo); + Map writeUnitTestingNullableInt40sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt40sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt40sCommandParams.put( - "value", unitTestingnullableInt40sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt40sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt40sAttribute", writeUnitTestingNullableInt40sAttributeInteractionInfo); - Map writeUnitTestingNullableInt48sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt40sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt40sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt40sAttribute", writeUnitTestingNullableInt40sAttributeInteractionInfo); + Map writeUnitTestingNullableInt48sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt48sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt48sCommandParams.put( - "value", unitTestingnullableInt48sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt48sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt48sAttribute", writeUnitTestingNullableInt48sAttributeInteractionInfo); - Map writeUnitTestingNullableInt56sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt48sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt48sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt48sAttribute", writeUnitTestingNullableInt48sAttributeInteractionInfo); + Map writeUnitTestingNullableInt56sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt56sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt56sCommandParams.put( - "value", unitTestingnullableInt56sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt56sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt56sAttribute", writeUnitTestingNullableInt56sAttributeInteractionInfo); - Map writeUnitTestingNullableInt64sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt56sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt56sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt56sAttribute", writeUnitTestingNullableInt56sAttributeInteractionInfo); + Map writeUnitTestingNullableInt64sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt64sCommandParameterInfo = - new CommandParameterInfo("value", Long.class, Long.class); + new CommandParameterInfo( + "value", + Long.class, + Long.class + ); writeUnitTestingNullableInt64sCommandParams.put( - "value", unitTestingnullableInt64sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt64sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableInt64sAttribute", writeUnitTestingNullableInt64sAttributeInteractionInfo); - Map writeUnitTestingNullableEnum8CommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableInt64sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt64sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableInt64sAttribute", writeUnitTestingNullableInt64sAttributeInteractionInfo); + Map writeUnitTestingNullableEnum8CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableEnum8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableEnum8CommandParams.put( - "value", unitTestingnullableEnum8CommandParameterInfo); - InteractionInfo writeUnitTestingNullableEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableEnum8CommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableEnum8Attribute", writeUnitTestingNullableEnum8AttributeInteractionInfo); - Map writeUnitTestingNullableEnum16CommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableEnum8CommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableEnum8CommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableEnum8Attribute", writeUnitTestingNullableEnum8AttributeInteractionInfo); + Map writeUnitTestingNullableEnum16CommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableEnum16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableEnum16CommandParams.put( - "value", unitTestingnullableEnum16CommandParameterInfo); - InteractionInfo writeUnitTestingNullableEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableEnum16CommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableEnum16Attribute", writeUnitTestingNullableEnum16AttributeInteractionInfo); - Map writeUnitTestingNullableFloatSingleCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableEnum16CommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableEnum16CommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableEnum16Attribute", writeUnitTestingNullableEnum16AttributeInteractionInfo); + Map writeUnitTestingNullableFloatSingleCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableFloatSingleCommandParameterInfo = - new CommandParameterInfo("value", Float.class, Float.class); + new CommandParameterInfo( + "value", + Float.class, + Float.class + ); writeUnitTestingNullableFloatSingleCommandParams.put( - "value", unitTestingnullableFloatSingleCommandParameterInfo); - InteractionInfo writeUnitTestingNullableFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableFloatSingleCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableFloatSingleAttribute", - writeUnitTestingNullableFloatSingleAttributeInteractionInfo); - Map writeUnitTestingNullableFloatDoubleCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableFloatSingleCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, + (Float) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableFloatSingleCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableFloatSingleAttribute", writeUnitTestingNullableFloatSingleAttributeInteractionInfo); + Map writeUnitTestingNullableFloatDoubleCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableFloatDoubleCommandParameterInfo = - new CommandParameterInfo("value", Double.class, Double.class); + new CommandParameterInfo( + "value", + Double.class, + Double.class + ); writeUnitTestingNullableFloatDoubleCommandParams.put( - "value", unitTestingnullableFloatDoubleCommandParameterInfo); - InteractionInfo writeUnitTestingNullableFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableFloatDoubleCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableFloatDoubleAttribute", - writeUnitTestingNullableFloatDoubleAttributeInteractionInfo); - Map writeUnitTestingNullableOctetStringCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableFloatDoubleCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, + (Double) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableFloatDoubleCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableFloatDoubleAttribute", writeUnitTestingNullableFloatDoubleAttributeInteractionInfo); + Map writeUnitTestingNullableOctetStringCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableOctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class, byte[].class); + new CommandParameterInfo( + "value", + byte[].class, + byte[].class + ); writeUnitTestingNullableOctetStringCommandParams.put( - "value", unitTestingnullableOctetStringCommandParameterInfo); - InteractionInfo writeUnitTestingNullableOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableOctetStringCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableOctetStringAttribute", - writeUnitTestingNullableOctetStringAttributeInteractionInfo); - Map writeUnitTestingNullableCharStringCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableOctetStringCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableOctetStringCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableOctetStringAttribute", writeUnitTestingNullableOctetStringAttributeInteractionInfo); + Map writeUnitTestingNullableCharStringCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableCharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class, String.class); + new CommandParameterInfo( + "value", + String.class, + String.class + ); writeUnitTestingNullableCharStringCommandParams.put( - "value", unitTestingnullableCharStringCommandParameterInfo); - InteractionInfo writeUnitTestingNullableCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableCharStringCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableCharStringAttribute", - writeUnitTestingNullableCharStringAttributeInteractionInfo); - Map writeUnitTestingNullableEnumAttrCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableCharStringCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, + (String) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableCharStringCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableCharStringAttribute", writeUnitTestingNullableCharStringAttributeInteractionInfo); + Map writeUnitTestingNullableEnumAttrCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableEnumAttrCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableEnumAttrCommandParams.put( - "value", unitTestingnullableEnumAttrCommandParameterInfo); - InteractionInfo writeUnitTestingNullableEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableEnumAttrCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableEnumAttrAttribute", writeUnitTestingNullableEnumAttrAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableEnumAttrCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableEnumAttrCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableEnumAttrAttribute", writeUnitTestingNullableEnumAttrAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableRangeRestrictedInt8uCommandParams.put( - "value", unitTestingnullableRangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt8uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableRangeRestrictedInt8uAttribute", - writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableRangeRestrictedInt8uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt8uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableRangeRestrictedInt8sCommandParams.put( - "value", unitTestingnullableRangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt8sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableRangeRestrictedInt8sAttribute", - writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableRangeRestrictedInt8sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt8sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableRangeRestrictedInt16uCommandParams.put( - "value", unitTestingnullableRangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt16uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableRangeRestrictedInt16uAttribute", - writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableRangeRestrictedInt16uCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt16uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingNullableRangeRestrictedInt16sCommandParams.put( - "value", unitTestingnullableRangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt16sCommandParams); - writeUnitTestingInteractionInfo.put( - "writeNullableRangeRestrictedInt16sAttribute", - writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map writeUnitTestingWriteOnlyInt8uCommandParams = - new LinkedHashMap(); + "value", + unitTestingnullableRangeRestrictedInt16sCommandParameterInfo + ); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt16sCommandParams + ); + writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map writeUnitTestingWriteOnlyInt8uCommandParams = new LinkedHashMap(); CommandParameterInfo unitTestingwriteOnlyInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class, Integer.class); + new CommandParameterInfo( + "value", + Integer.class, + Integer.class + ); writeUnitTestingWriteOnlyInt8uCommandParams.put( - "value", unitTestingwriteOnlyInt8uCommandParameterInfo); - InteractionInfo writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster) - .writeWriteOnlyInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingWriteOnlyInt8uCommandParams); - writeUnitTestingInteractionInfo.put( - "writeWriteOnlyInt8uAttribute", writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo); + "value", + unitTestingwriteOnlyInt8uCommandParameterInfo + ); + InteractionInfo writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster).writeWriteOnlyInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value") + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingWriteOnlyInt8uCommandParams + ); + writeUnitTestingInteractionInfo.put("writeWriteOnlyInt8uAttribute", writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo); writeAttributeMap.put("unitTesting", writeUnitTestingInteractionInfo); Map writeFaultInjectionInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("faultInjection", writeFaultInjectionInteractionInfo); - return writeAttributeMap; + writeAttributeMap.put("faultInjection", writeFaultInjectionInteractionInfo);return writeAttributeMap; } } From f6144d7e11d75dcb137156820ef2394c92393e7e Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Wed, 24 May 2023 12:36:47 -0400 Subject: [PATCH 06/14] Commits after regen-all --- .../devicecontroller/ClusterIDMapping.java | 28237 ++++++------ .../devicecontroller/ClusterReadMapping.java | 35571 +++++++++------- .../devicecontroller/ClusterWriteMapping.java | 7753 ++-- 3 files changed, 38596 insertions(+), 32965 deletions(-) diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index 641d827ded0a63..908bd1bfd381e8 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -17,13117 +17,15292 @@ package chip.devicecontroller; public class ClusterIDMapping { - public interface BaseCluster { - long getID(); - String getAttributeName(long id) throws NoSuchFieldError; - String getEventName(long id) throws NoSuchFieldError; - String getCommandName(long id) throws NoSuchFieldError; - long getAttributeID(String name) throws IllegalArgumentException; - long getEventID(String name) throws IllegalArgumentException; - long getCommandID(String name) throws IllegalArgumentException; + public interface BaseCluster { + long getID(); + + String getAttributeName(long id) throws NoSuchFieldError; + + String getEventName(long id) throws NoSuchFieldError; + + String getCommandName(long id) throws NoSuchFieldError; + + long getAttributeID(String name) throws IllegalArgumentException; + + long getEventID(String name) throws IllegalArgumentException; + + long getCommandID(String name) throws IllegalArgumentException; + } + + public static BaseCluster getCluster(long clusterId) { + if (clusterId == Identify.ID) { + return new Identify(); + } + if (clusterId == Groups.ID) { + return new Groups(); + } + if (clusterId == Scenes.ID) { + return new Scenes(); + } + if (clusterId == OnOff.ID) { + return new OnOff(); + } + if (clusterId == OnOffSwitchConfiguration.ID) { + return new OnOffSwitchConfiguration(); + } + if (clusterId == LevelControl.ID) { + return new LevelControl(); + } + if (clusterId == BinaryInputBasic.ID) { + return new BinaryInputBasic(); + } + if (clusterId == PulseWidthModulation.ID) { + return new PulseWidthModulation(); + } + if (clusterId == Descriptor.ID) { + return new Descriptor(); + } + if (clusterId == Binding.ID) { + return new Binding(); + } + if (clusterId == AccessControl.ID) { + return new AccessControl(); + } + if (clusterId == Actions.ID) { + return new Actions(); + } + if (clusterId == BasicInformation.ID) { + return new BasicInformation(); + } + if (clusterId == OtaSoftwareUpdateProvider.ID) { + return new OtaSoftwareUpdateProvider(); + } + if (clusterId == OtaSoftwareUpdateRequestor.ID) { + return new OtaSoftwareUpdateRequestor(); + } + if (clusterId == LocalizationConfiguration.ID) { + return new LocalizationConfiguration(); + } + if (clusterId == TimeFormatLocalization.ID) { + return new TimeFormatLocalization(); + } + if (clusterId == UnitLocalization.ID) { + return new UnitLocalization(); + } + if (clusterId == PowerSourceConfiguration.ID) { + return new PowerSourceConfiguration(); + } + if (clusterId == PowerSource.ID) { + return new PowerSource(); + } + if (clusterId == GeneralCommissioning.ID) { + return new GeneralCommissioning(); + } + if (clusterId == NetworkCommissioning.ID) { + return new NetworkCommissioning(); + } + if (clusterId == DiagnosticLogs.ID) { + return new DiagnosticLogs(); + } + if (clusterId == GeneralDiagnostics.ID) { + return new GeneralDiagnostics(); + } + if (clusterId == SoftwareDiagnostics.ID) { + return new SoftwareDiagnostics(); + } + if (clusterId == ThreadNetworkDiagnostics.ID) { + return new ThreadNetworkDiagnostics(); + } + if (clusterId == WiFiNetworkDiagnostics.ID) { + return new WiFiNetworkDiagnostics(); + } + if (clusterId == EthernetNetworkDiagnostics.ID) { + return new EthernetNetworkDiagnostics(); + } + if (clusterId == TimeSynchronization.ID) { + return new TimeSynchronization(); + } + if (clusterId == BridgedDeviceBasicInformation.ID) { + return new BridgedDeviceBasicInformation(); + } + if (clusterId == Switch.ID) { + return new Switch(); + } + if (clusterId == AdministratorCommissioning.ID) { + return new AdministratorCommissioning(); + } + if (clusterId == OperationalCredentials.ID) { + return new OperationalCredentials(); + } + if (clusterId == GroupKeyManagement.ID) { + return new GroupKeyManagement(); + } + if (clusterId == FixedLabel.ID) { + return new FixedLabel(); + } + if (clusterId == UserLabel.ID) { + return new UserLabel(); + } + if (clusterId == ProxyConfiguration.ID) { + return new ProxyConfiguration(); + } + if (clusterId == ProxyDiscovery.ID) { + return new ProxyDiscovery(); + } + if (clusterId == ProxyValid.ID) { + return new ProxyValid(); + } + if (clusterId == BooleanState.ID) { + return new BooleanState(); + } + if (clusterId == IcdManagement.ID) { + return new IcdManagement(); + } + if (clusterId == ModeSelect.ID) { + return new ModeSelect(); + } + if (clusterId == TemperatureControl.ID) { + return new TemperatureControl(); + } + if (clusterId == RefrigeratorAlarm.ID) { + return new RefrigeratorAlarm(); + } + if (clusterId == AirQuality.ID) { + return new AirQuality(); + } + if (clusterId == SmokeCoAlarm.ID) { + return new SmokeCoAlarm(); + } + if (clusterId == DishwasherAlarm.ID) { + return new DishwasherAlarm(); + } + if (clusterId == HepaFilterMonitoring.ID) { + return new HepaFilterMonitoring(); + } + if (clusterId == ActivatedCarbonFilterMonitoring.ID) { + return new ActivatedCarbonFilterMonitoring(); + } + if (clusterId == CeramicFilterMonitoring.ID) { + return new CeramicFilterMonitoring(); + } + if (clusterId == ElectrostaticFilterMonitoring.ID) { + return new ElectrostaticFilterMonitoring(); + } + if (clusterId == UvFilterMonitoring.ID) { + return new UvFilterMonitoring(); + } + if (clusterId == IonizingFilterMonitoring.ID) { + return new IonizingFilterMonitoring(); + } + if (clusterId == ZeoliteFilterMonitoring.ID) { + return new ZeoliteFilterMonitoring(); + } + if (clusterId == OzoneFilterMonitoring.ID) { + return new OzoneFilterMonitoring(); + } + if (clusterId == WaterTankMonitoring.ID) { + return new WaterTankMonitoring(); + } + if (clusterId == FuelTankMonitoring.ID) { + return new FuelTankMonitoring(); + } + if (clusterId == InkCartridgeMonitoring.ID) { + return new InkCartridgeMonitoring(); } + if (clusterId == TonerCartridgeMonitoring.ID) { + return new TonerCartridgeMonitoring(); + } + if (clusterId == DoorLock.ID) { + return new DoorLock(); + } + if (clusterId == WindowCovering.ID) { + return new WindowCovering(); + } + if (clusterId == BarrierControl.ID) { + return new BarrierControl(); + } + if (clusterId == PumpConfigurationAndControl.ID) { + return new PumpConfigurationAndControl(); + } + if (clusterId == Thermostat.ID) { + return new Thermostat(); + } + if (clusterId == FanControl.ID) { + return new FanControl(); + } + if (clusterId == ThermostatUserInterfaceConfiguration.ID) { + return new ThermostatUserInterfaceConfiguration(); + } + if (clusterId == ColorControl.ID) { + return new ColorControl(); + } + if (clusterId == BallastConfiguration.ID) { + return new BallastConfiguration(); + } + if (clusterId == IlluminanceMeasurement.ID) { + return new IlluminanceMeasurement(); + } + if (clusterId == TemperatureMeasurement.ID) { + return new TemperatureMeasurement(); + } + if (clusterId == PressureMeasurement.ID) { + return new PressureMeasurement(); + } + if (clusterId == FlowMeasurement.ID) { + return new FlowMeasurement(); + } + if (clusterId == RelativeHumidityMeasurement.ID) { + return new RelativeHumidityMeasurement(); + } + if (clusterId == OccupancySensing.ID) { + return new OccupancySensing(); + } + if (clusterId == WakeOnLan.ID) { + return new WakeOnLan(); + } + if (clusterId == Channel.ID) { + return new Channel(); + } + if (clusterId == TargetNavigator.ID) { + return new TargetNavigator(); + } + if (clusterId == MediaPlayback.ID) { + return new MediaPlayback(); + } + if (clusterId == MediaInput.ID) { + return new MediaInput(); + } + if (clusterId == LowPower.ID) { + return new LowPower(); + } + if (clusterId == KeypadInput.ID) { + return new KeypadInput(); + } + if (clusterId == ContentLauncher.ID) { + return new ContentLauncher(); + } + if (clusterId == AudioOutput.ID) { + return new AudioOutput(); + } + if (clusterId == ApplicationLauncher.ID) { + return new ApplicationLauncher(); + } + if (clusterId == ApplicationBasic.ID) { + return new ApplicationBasic(); + } + if (clusterId == AccountLogin.ID) { + return new AccountLogin(); + } + if (clusterId == ElectricalMeasurement.ID) { + return new ElectricalMeasurement(); + } + if (clusterId == UnitTesting.ID) { + return new UnitTesting(); + } + if (clusterId == FaultInjection.ID) { + return new FaultInjection(); + } + return null; + } - public static BaseCluster getCluster(long clusterId) { - if (clusterId == Identify.ID) { - return new Identify(); - } - if (clusterId == Groups.ID) { - return new Groups(); - } - if (clusterId == Scenes.ID) { - return new Scenes(); - } - if (clusterId == OnOff.ID) { - return new OnOff(); - } - if (clusterId == OnOffSwitchConfiguration.ID) { - return new OnOffSwitchConfiguration(); - } - if (clusterId == LevelControl.ID) { - return new LevelControl(); + public static class Identify implements BaseCluster { + public static final long ID = 3L; + + public long getID() { + return ID; + } + + public enum Attribute { + IdentifyTime(0L), + IdentifyType(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == BinaryInputBasic.ID) { - return new BinaryInputBasic(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + Identify(0L), + TriggerEffect(64L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == PulseWidthModulation.ID) { - return new PulseWidthModulation(); + throw new NoSuchFieldError(); + } + } + + public enum IdentifyCommandField { + IdentifyTime(0), + ; + private final int id; + + IdentifyCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static IdentifyCommandField value(int id) throws NoSuchFieldError { + for (IdentifyCommandField field : IdentifyCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == Descriptor.ID) { - return new Descriptor(); + throw new NoSuchFieldError(); + } + } + + public enum TriggerEffectCommandField { + EffectIdentifier(0), + EffectVariant(1), + ; + private final int id; + + TriggerEffectCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TriggerEffectCommandField value(int id) throws NoSuchFieldError { + for (TriggerEffectCommandField field : TriggerEffectCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == Binding.ID) { - return new Binding(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Groups implements BaseCluster { + public static final long ID = 4L; + + public long getID() { + return ID; + } + + public enum Attribute { + NameSupport(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == AccessControl.ID) { - return new AccessControl(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + AddGroup(0L), + ViewGroup(1L), + GetGroupMembership(2L), + RemoveGroup(3L), + RemoveAllGroups(4L), + AddGroupIfIdentifying(5L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AddGroupCommandField { + GroupID(0), + GroupName(1), + ; + private final int id; + + AddGroupCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddGroupCommandField value(int id) throws NoSuchFieldError { + for (AddGroupCommandField field : AddGroupCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == Actions.ID) { - return new Actions(); + throw new NoSuchFieldError(); + } + } + + public enum ViewGroupCommandField { + GroupID(0), + ; + private final int id; + + ViewGroupCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ViewGroupCommandField value(int id) throws NoSuchFieldError { + for (ViewGroupCommandField field : ViewGroupCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == BasicInformation.ID) { - return new BasicInformation(); + throw new NoSuchFieldError(); + } + } + + public enum GetGroupMembershipCommandField { + GroupList(0), + ; + private final int id; + + GetGroupMembershipCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetGroupMembershipCommandField value(int id) throws NoSuchFieldError { + for (GetGroupMembershipCommandField field : GetGroupMembershipCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == OtaSoftwareUpdateProvider.ID) { - return new OtaSoftwareUpdateProvider(); + throw new NoSuchFieldError(); + } + } + + public enum RemoveGroupCommandField { + GroupID(0), + ; + private final int id; + + RemoveGroupCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RemoveGroupCommandField value(int id) throws NoSuchFieldError { + for (RemoveGroupCommandField field : RemoveGroupCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == OtaSoftwareUpdateRequestor.ID) { - return new OtaSoftwareUpdateRequestor(); + throw new NoSuchFieldError(); + } + } + + public enum AddGroupIfIdentifyingCommandField { + GroupID(0), + GroupName(1), + ; + private final int id; + + AddGroupIfIdentifyingCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddGroupIfIdentifyingCommandField value(int id) throws NoSuchFieldError { + for (AddGroupIfIdentifyingCommandField field : AddGroupIfIdentifyingCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == LocalizationConfiguration.ID) { - return new LocalizationConfiguration(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Scenes implements BaseCluster { + public static final long ID = 5L; + + public long getID() { + return ID; + } + + public enum Attribute { + SceneCount(0L), + CurrentScene(1L), + CurrentGroup(2L), + SceneValid(3L), + NameSupport(4L), + LastConfiguredBy(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == TimeFormatLocalization.ID) { - return new TimeFormatLocalization(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + AddScene(0L), + ViewScene(1L), + RemoveScene(2L), + RemoveAllScenes(3L), + StoreScene(4L), + RecallScene(5L), + GetSceneMembership(6L), + EnhancedAddScene(64L), + EnhancedViewScene(65L), + CopyScene(66L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AddSceneCommandField { + GroupID(0), + SceneID(1), + TransitionTime(2), + SceneName(3), + ExtensionFieldSets(4), + ; + private final int id; + + AddSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddSceneCommandField value(int id) throws NoSuchFieldError { + for (AddSceneCommandField field : AddSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ViewSceneCommandField { + GroupID(0), + SceneID(1), + ; + private final int id; + + ViewSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ViewSceneCommandField value(int id) throws NoSuchFieldError { + for (ViewSceneCommandField field : ViewSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == UnitLocalization.ID) { - return new UnitLocalization(); + throw new NoSuchFieldError(); + } + } + + public enum RemoveSceneCommandField { + GroupID(0), + SceneID(1), + ; + private final int id; + + RemoveSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RemoveSceneCommandField value(int id) throws NoSuchFieldError { + for (RemoveSceneCommandField field : RemoveSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == PowerSourceConfiguration.ID) { - return new PowerSourceConfiguration(); + throw new NoSuchFieldError(); + } + } + + public enum RemoveAllScenesCommandField { + GroupID(0), + ; + private final int id; + + RemoveAllScenesCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RemoveAllScenesCommandField value(int id) throws NoSuchFieldError { + for (RemoveAllScenesCommandField field : RemoveAllScenesCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == PowerSource.ID) { - return new PowerSource(); + throw new NoSuchFieldError(); + } + } + + public enum StoreSceneCommandField { + GroupID(0), + SceneID(1), + ; + private final int id; + + StoreSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StoreSceneCommandField value(int id) throws NoSuchFieldError { + for (StoreSceneCommandField field : StoreSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == GeneralCommissioning.ID) { - return new GeneralCommissioning(); + throw new NoSuchFieldError(); + } + } + + public enum RecallSceneCommandField { + GroupID(0), + SceneID(1), + TransitionTime(2), + ; + private final int id; + + RecallSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RecallSceneCommandField value(int id) throws NoSuchFieldError { + for (RecallSceneCommandField field : RecallSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetSceneMembershipCommandField { + GroupID(0), + ; + private final int id; + + GetSceneMembershipCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetSceneMembershipCommandField value(int id) throws NoSuchFieldError { + for (GetSceneMembershipCommandField field : GetSceneMembershipCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == NetworkCommissioning.ID) { - return new NetworkCommissioning(); + throw new NoSuchFieldError(); + } + } + + public enum EnhancedAddSceneCommandField { + GroupID(0), + SceneID(1), + TransitionTime(2), + SceneName(3), + ExtensionFieldSets(4), + ; + private final int id; + + EnhancedAddSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnhancedAddSceneCommandField value(int id) throws NoSuchFieldError { + for (EnhancedAddSceneCommandField field : EnhancedAddSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnhancedViewSceneCommandField { + GroupID(0), + SceneID(1), + ; + private final int id; + + EnhancedViewSceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnhancedViewSceneCommandField value(int id) throws NoSuchFieldError { + for (EnhancedViewSceneCommandField field : EnhancedViewSceneCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == DiagnosticLogs.ID) { - return new DiagnosticLogs(); + throw new NoSuchFieldError(); + } + } + + public enum CopySceneCommandField { + Mode(0), + GroupIdentifierFrom(1), + SceneIdentifierFrom(2), + GroupIdentifierTo(3), + SceneIdentifierTo(4), + ; + private final int id; + + CopySceneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static CopySceneCommandField value(int id) throws NoSuchFieldError { + for (CopySceneCommandField field : CopySceneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OnOff implements BaseCluster { + public static final long ID = 6L; + + public long getID() { + return ID; + } + + public enum Attribute { + OnOff(0L), + GlobalSceneControl(16384L), + OnTime(16385L), + OffWaitTime(16386L), + StartUpOnOff(16387L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == GeneralDiagnostics.ID) { - return new GeneralDiagnostics(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + Off(0L), + On(1L), + Toggle(2L), + OffWithEffect(64L), + OnWithRecallGlobalScene(65L), + OnWithTimedOff(66L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum OffWithEffectCommandField { + EffectIdentifier(0), + EffectVariant(1), + ; + private final int id; + + OffWithEffectCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static OffWithEffectCommandField value(int id) throws NoSuchFieldError { + for (OffWithEffectCommandField field : OffWithEffectCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum OnWithTimedOffCommandField { + OnOffControl(0), + OnTime(1), + OffWaitTime(2), + ; + private final int id; + + OnWithTimedOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static OnWithTimedOffCommandField value(int id) throws NoSuchFieldError { + for (OnWithTimedOffCommandField field : OnWithTimedOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OnOffSwitchConfiguration implements BaseCluster { + public static final long ID = 7L; + + public long getID() { + return ID; + } + + public enum Attribute { + SwitchType(0L), + SwitchActions(16L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class LevelControl implements BaseCluster { + public static final long ID = 8L; + + public long getID() { + return ID; + } + + public enum Attribute { + CurrentLevel(0L), + RemainingTime(1L), + MinLevel(2L), + MaxLevel(3L), + CurrentFrequency(4L), + MinFrequency(5L), + MaxFrequency(6L), + Options(15L), + OnOffTransitionTime(16L), + OnLevel(17L), + OnTransitionTime(18L), + OffTransitionTime(19L), + DefaultMoveRate(20L), + StartUpCurrentLevel(16384L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + MoveToLevel(0L), + Move(1L), + Step(2L), + Stop(3L), + MoveToLevelWithOnOff(4L), + MoveWithOnOff(5L), + StepWithOnOff(6L), + StopWithOnOff(7L), + MoveToClosestFrequency(8L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToLevelCommandField { + Level(0), + TransitionTime(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveToLevelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToLevelCommandField value(int id) throws NoSuchFieldError { + for (MoveToLevelCommandField field : MoveToLevelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveCommandField { + MoveMode(0), + Rate(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveCommandField value(int id) throws NoSuchFieldError { + for (MoveCommandField field : MoveCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StepCommandField { + StepMode(0), + StepSize(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + StepCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StepCommandField value(int id) throws NoSuchFieldError { + for (StepCommandField field : StepCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StopCommandField { + OptionsMask(0), + OptionsOverride(1), + ; + private final int id; + + StopCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StopCommandField value(int id) throws NoSuchFieldError { + for (StopCommandField field : StopCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToLevelWithOnOffCommandField { + Level(0), + TransitionTime(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveToLevelWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToLevelWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (MoveToLevelWithOnOffCommandField field : MoveToLevelWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveWithOnOffCommandField { + MoveMode(0), + Rate(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (MoveWithOnOffCommandField field : MoveWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StepWithOnOffCommandField { + StepMode(0), + StepSize(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + StepWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StepWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (StepWithOnOffCommandField field : StepWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StopWithOnOffCommandField { + OptionsMask(0), + OptionsOverride(1), + ; + private final int id; + + StopWithOnOffCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StopWithOnOffCommandField value(int id) throws NoSuchFieldError { + for (StopWithOnOffCommandField field : StopWithOnOffCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToClosestFrequencyCommandField { + Frequency(0), + ; + private final int id; + + MoveToClosestFrequencyCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToClosestFrequencyCommandField value(int id) throws NoSuchFieldError { + for (MoveToClosestFrequencyCommandField field : + MoveToClosestFrequencyCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class BinaryInputBasic implements BaseCluster { + public static final long ID = 15L; + + public long getID() { + return ID; + } + + public enum Attribute { + ActiveText(4L), + Description(28L), + InactiveText(46L), + OutOfService(81L), + Polarity(84L), + PresentValue(85L), + Reliability(103L), + StatusFlags(111L), + ApplicationType(256L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class PulseWidthModulation implements BaseCluster { + public static final long ID = 28L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Descriptor implements BaseCluster { + public static final long ID = 29L; + + public long getID() { + return ID; + } + + public enum Attribute { + DeviceTypeList(0L), + ServerList(1L), + ClientList(2L), + PartsList(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Binding implements BaseCluster { + public static final long ID = 30L; + + public long getID() { + return ID; + } + + public enum Attribute { + Binding(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class AccessControl implements BaseCluster { + public static final long ID = 31L; + + public long getID() { + return ID; + } + + public enum Attribute { + Acl(0L), + Extension(1L), + SubjectsPerAccessControlEntry(2L), + TargetsPerAccessControlEntry(3L), + AccessControlEntriesPerFabric(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + AccessControlEntryChanged(0L), + AccessControlExtensionChanged(1L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Actions implements BaseCluster { + public static final long ID = 37L; + + public long getID() { + return ID; + } + + public enum Attribute { + ActionList(0L), + EndpointLists(1L), + SetupURL(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StateChanged(0L), + ActionFailed(1L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + InstantAction(0L), + InstantActionWithTransition(1L), + StartAction(2L), + StartActionWithDuration(3L), + StopAction(4L), + PauseAction(5L), + PauseActionWithDuration(6L), + ResumeAction(7L), + EnableAction(8L), + EnableActionWithDuration(9L), + DisableAction(10L), + DisableActionWithDuration(11L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum InstantActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + InstantActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static InstantActionCommandField value(int id) throws NoSuchFieldError { + for (InstantActionCommandField field : InstantActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum InstantActionWithTransitionCommandField { + ActionID(0), + InvokeID(1), + TransitionTime(2), + ; + private final int id; + + InstantActionWithTransitionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static InstantActionWithTransitionCommandField value(int id) throws NoSuchFieldError { + for (InstantActionWithTransitionCommandField field : + InstantActionWithTransitionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StartActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + StartActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StartActionCommandField value(int id) throws NoSuchFieldError { + for (StartActionCommandField field : StartActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StartActionWithDurationCommandField { + ActionID(0), + InvokeID(1), + Duration(2), + ; + private final int id; + + StartActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StartActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (StartActionWithDurationCommandField field : + StartActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StopActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + StopActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StopActionCommandField value(int id) throws NoSuchFieldError { + for (StopActionCommandField field : StopActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum PauseActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + PauseActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static PauseActionCommandField value(int id) throws NoSuchFieldError { + for (PauseActionCommandField field : PauseActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum PauseActionWithDurationCommandField { + ActionID(0), + InvokeID(1), + Duration(2), + ; + private final int id; + + PauseActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static PauseActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (PauseActionWithDurationCommandField field : + PauseActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ResumeActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + ResumeActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ResumeActionCommandField value(int id) throws NoSuchFieldError { + for (ResumeActionCommandField field : ResumeActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnableActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + EnableActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnableActionCommandField value(int id) throws NoSuchFieldError { + for (EnableActionCommandField field : EnableActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnableActionWithDurationCommandField { + ActionID(0), + InvokeID(1), + Duration(2), + ; + private final int id; + + EnableActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnableActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (EnableActionWithDurationCommandField field : + EnableActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum DisableActionCommandField { + ActionID(0), + InvokeID(1), + ; + private final int id; + + DisableActionCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static DisableActionCommandField value(int id) throws NoSuchFieldError { + for (DisableActionCommandField field : DisableActionCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum DisableActionWithDurationCommandField { + ActionID(0), + InvokeID(1), + Duration(2), + ; + private final int id; + + DisableActionWithDurationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static DisableActionWithDurationCommandField value(int id) throws NoSuchFieldError { + for (DisableActionWithDurationCommandField field : + DisableActionWithDurationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class BasicInformation implements BaseCluster { + public static final long ID = 40L; + + public long getID() { + return ID; + } + + public enum Attribute { + DataModelRevision(0L), + VendorName(1L), + VendorID(2L), + ProductName(3L), + ProductID(4L), + NodeLabel(5L), + Location(6L), + HardwareVersion(7L), + HardwareVersionString(8L), + SoftwareVersion(9L), + SoftwareVersionString(10L), + ManufacturingDate(11L), + PartNumber(12L), + ProductURL(13L), + ProductLabel(14L), + SerialNumber(15L), + LocalConfigDisabled(16L), + Reachable(17L), + UniqueID(18L), + CapabilityMinima(19L), + ProductAppearance(20L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StartUp(0L), + ShutDown(1L), + Leave(2L), + ReachableChanged(3L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + MfgSpecificPing(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OtaSoftwareUpdateProvider implements BaseCluster { + public static final long ID = 41L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + QueryImage(0L), + ApplyUpdateRequest(2L), + NotifyUpdateApplied(4L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum QueryImageCommandField { + VendorID(0), + ProductID(1), + SoftwareVersion(2), + ProtocolsSupported(3), + HardwareVersion(4), + Location(5), + RequestorCanConsent(6), + MetadataForProvider(7), + ; + private final int id; + + QueryImageCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static QueryImageCommandField value(int id) throws NoSuchFieldError { + for (QueryImageCommandField field : QueryImageCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ApplyUpdateRequestCommandField { + UpdateToken(0), + NewVersion(1), + ; + private final int id; + + ApplyUpdateRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ApplyUpdateRequestCommandField value(int id) throws NoSuchFieldError { + for (ApplyUpdateRequestCommandField field : ApplyUpdateRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum NotifyUpdateAppliedCommandField { + UpdateToken(0), + SoftwareVersion(1), + ; + private final int id; + + NotifyUpdateAppliedCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static NotifyUpdateAppliedCommandField value(int id) throws NoSuchFieldError { + for (NotifyUpdateAppliedCommandField field : NotifyUpdateAppliedCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OtaSoftwareUpdateRequestor implements BaseCluster { + public static final long ID = 42L; + + public long getID() { + return ID; + } + + public enum Attribute { + DefaultOTAProviders(0L), + UpdatePossible(1L), + UpdateState(2L), + UpdateStateProgress(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StateTransition(0L), + VersionApplied(1L), + DownloadError(2L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + AnnounceOTAProvider(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AnnounceOTAProviderCommandField { + ProviderNodeID(0), + VendorID(1), + AnnouncementReason(2), + MetadataForNode(3), + Endpoint(4), + ; + private final int id; + + AnnounceOTAProviderCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AnnounceOTAProviderCommandField value(int id) throws NoSuchFieldError { + for (AnnounceOTAProviderCommandField field : AnnounceOTAProviderCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class LocalizationConfiguration implements BaseCluster { + public static final long ID = 43L; + + public long getID() { + return ID; + } + + public enum Attribute { + ActiveLocale(0L), + SupportedLocales(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class TimeFormatLocalization implements BaseCluster { + public static final long ID = 44L; + + public long getID() { + return ID; + } + + public enum Attribute { + HourFormat(0L), + ActiveCalendarType(1L), + SupportedCalendarTypes(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class UnitLocalization implements BaseCluster { + public static final long ID = 45L; + + public long getID() { + return ID; + } + + public enum Attribute { + TemperatureUnit(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class PowerSourceConfiguration implements BaseCluster { + public static final long ID = 46L; + + public long getID() { + return ID; + } + + public enum Attribute { + Sources(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class PowerSource implements BaseCluster { + public static final long ID = 47L; + + public long getID() { + return ID; + } + + public enum Attribute { + Status(0L), + Order(1L), + Description(2L), + WiredAssessedInputVoltage(3L), + WiredAssessedInputFrequency(4L), + WiredCurrentType(5L), + WiredAssessedCurrent(6L), + WiredNominalVoltage(7L), + WiredMaximumCurrent(8L), + WiredPresent(9L), + ActiveWiredFaults(10L), + BatVoltage(11L), + BatPercentRemaining(12L), + BatTimeRemaining(13L), + BatChargeLevel(14L), + BatReplacementNeeded(15L), + BatReplaceability(16L), + BatPresent(17L), + ActiveBatFaults(18L), + BatReplacementDescription(19L), + BatCommonDesignation(20L), + BatANSIDesignation(21L), + BatIECDesignation(22L), + BatApprovedChemistry(23L), + BatCapacity(24L), + BatQuantity(25L), + BatChargeState(26L), + BatTimeToFullCharge(27L), + BatFunctionalWhileCharging(28L), + BatChargingCurrent(29L), + ActiveBatChargeFaults(30L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + WiredFaultChange(0L), + BatFaultChange(1L), + BatChargeFaultChange(2L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class GeneralCommissioning implements BaseCluster { + public static final long ID = 48L; + + public long getID() { + return ID; + } + + public enum Attribute { + Breadcrumb(0L), + BasicCommissioningInfo(1L), + RegulatoryConfig(2L), + LocationCapability(3L), + SupportsConcurrentConnection(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ArmFailSafe(0L), + SetRegulatoryConfig(2L), + CommissioningComplete(4L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ArmFailSafeCommandField { + ExpiryLengthSeconds(0), + Breadcrumb(1), + ; + private final int id; + + ArmFailSafeCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ArmFailSafeCommandField value(int id) throws NoSuchFieldError { + for (ArmFailSafeCommandField field : ArmFailSafeCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetRegulatoryConfigCommandField { + NewRegulatoryConfig(0), + CountryCode(1), + Breadcrumb(2), + ; + private final int id; + + SetRegulatoryConfigCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetRegulatoryConfigCommandField value(int id) throws NoSuchFieldError { + for (SetRegulatoryConfigCommandField field : SetRegulatoryConfigCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class NetworkCommissioning implements BaseCluster { + public static final long ID = 49L; + + public long getID() { + return ID; + } + + public enum Attribute { + MaxNetworks(0L), + Networks(1L), + ScanMaxTimeSeconds(2L), + ConnectMaxTimeSeconds(3L), + InterfaceEnabled(4L), + LastNetworkingStatus(5L), + LastNetworkID(6L), + LastConnectErrorValue(7L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ScanNetworks(0L), + AddOrUpdateWiFiNetwork(2L), + AddOrUpdateThreadNetwork(3L), + RemoveNetwork(4L), + ConnectNetwork(6L), + ReorderNetwork(8L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ScanNetworksCommandField { + Ssid(0), + Breadcrumb(1), + ; + private final int id; + + ScanNetworksCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ScanNetworksCommandField value(int id) throws NoSuchFieldError { + for (ScanNetworksCommandField field : ScanNetworksCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AddOrUpdateWiFiNetworkCommandField { + Ssid(0), + Credentials(1), + Breadcrumb(2), + ; + private final int id; + + AddOrUpdateWiFiNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddOrUpdateWiFiNetworkCommandField value(int id) throws NoSuchFieldError { + for (AddOrUpdateWiFiNetworkCommandField field : + AddOrUpdateWiFiNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AddOrUpdateThreadNetworkCommandField { + OperationalDataset(0), + Breadcrumb(1), + ; + private final int id; + + AddOrUpdateThreadNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddOrUpdateThreadNetworkCommandField value(int id) throws NoSuchFieldError { + for (AddOrUpdateThreadNetworkCommandField field : + AddOrUpdateThreadNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum RemoveNetworkCommandField { + NetworkID(0), + Breadcrumb(1), + ; + private final int id; + + RemoveNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RemoveNetworkCommandField value(int id) throws NoSuchFieldError { + for (RemoveNetworkCommandField field : RemoveNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ConnectNetworkCommandField { + NetworkID(0), + Breadcrumb(1), + ; + private final int id; + + ConnectNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ConnectNetworkCommandField value(int id) throws NoSuchFieldError { + for (ConnectNetworkCommandField field : ConnectNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ReorderNetworkCommandField { + NetworkID(0), + NetworkIndex(1), + Breadcrumb(2), + ; + private final int id; + + ReorderNetworkCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ReorderNetworkCommandField value(int id) throws NoSuchFieldError { + for (ReorderNetworkCommandField field : ReorderNetworkCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class DiagnosticLogs implements BaseCluster { + public static final long ID = 50L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + RetrieveLogsRequest(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum RetrieveLogsRequestCommandField { + Intent(0), + RequestedProtocol(1), + TransferFileDesignator(2), + ; + private final int id; + + RetrieveLogsRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RetrieveLogsRequestCommandField value(int id) throws NoSuchFieldError { + for (RetrieveLogsRequestCommandField field : RetrieveLogsRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class GeneralDiagnostics implements BaseCluster { + public static final long ID = 51L; + + public long getID() { + return ID; + } + + public enum Attribute { + NetworkInterfaces(0L), + RebootCount(1L), + UpTime(2L), + TotalOperationalHours(3L), + BootReason(4L), + ActiveHardwareFaults(5L), + ActiveRadioFaults(6L), + ActiveNetworkFaults(7L), + TestEventTriggersEnabled(8L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + HardwareFaultChange(0L), + RadioFaultChange(1L), + NetworkFaultChange(2L), + BootReason(3L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + TestEventTrigger(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestEventTriggerCommandField { + EnableKey(0), + EventTrigger(1), + ; + private final int id; + + TestEventTriggerCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestEventTriggerCommandField value(int id) throws NoSuchFieldError { + for (TestEventTriggerCommandField field : TestEventTriggerCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class SoftwareDiagnostics implements BaseCluster { + public static final long ID = 52L; + + public long getID() { + return ID; + } + + public enum Attribute { + ThreadMetrics(0L), + CurrentHeapFree(1L), + CurrentHeapUsed(2L), + CurrentHeapHighWatermark(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SoftwareFault(0L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetWatermarks(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ThreadNetworkDiagnostics implements BaseCluster { + public static final long ID = 53L; + + public long getID() { + return ID; + } + + public enum Attribute { + Channel(0L), + RoutingRole(1L), + NetworkName(2L), + PanId(3L), + ExtendedPanId(4L), + MeshLocalPrefix(5L), + OverrunCount(6L), + NeighborTable(7L), + RouteTable(8L), + PartitionId(9L), + Weighting(10L), + DataVersion(11L), + StableDataVersion(12L), + LeaderRouterId(13L), + DetachedRoleCount(14L), + ChildRoleCount(15L), + RouterRoleCount(16L), + LeaderRoleCount(17L), + AttachAttemptCount(18L), + PartitionIdChangeCount(19L), + BetterPartitionAttachAttemptCount(20L), + ParentChangeCount(21L), + TxTotalCount(22L), + TxUnicastCount(23L), + TxBroadcastCount(24L), + TxAckRequestedCount(25L), + TxAckedCount(26L), + TxNoAckRequestedCount(27L), + TxDataCount(28L), + TxDataPollCount(29L), + TxBeaconCount(30L), + TxBeaconRequestCount(31L), + TxOtherCount(32L), + TxRetryCount(33L), + TxDirectMaxRetryExpiryCount(34L), + TxIndirectMaxRetryExpiryCount(35L), + TxErrCcaCount(36L), + TxErrAbortCount(37L), + TxErrBusyChannelCount(38L), + RxTotalCount(39L), + RxUnicastCount(40L), + RxBroadcastCount(41L), + RxDataCount(42L), + RxDataPollCount(43L), + RxBeaconCount(44L), + RxBeaconRequestCount(45L), + RxOtherCount(46L), + RxAddressFilteredCount(47L), + RxDestAddrFilteredCount(48L), + RxDuplicatedCount(49L), + RxErrNoFrameCount(50L), + RxErrUnknownNeighborCount(51L), + RxErrInvalidSrcAddrCount(52L), + RxErrSecCount(53L), + RxErrFcsCount(54L), + RxErrOtherCount(55L), + ActiveTimestamp(56L), + PendingTimestamp(57L), + Delay(58L), + SecurityPolicy(59L), + ChannelPage0Mask(60L), + OperationalDatasetComponents(61L), + ActiveNetworkFaultsList(62L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ConnectionStatus(0L), + NetworkFaultChange(1L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCounts(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class WiFiNetworkDiagnostics implements BaseCluster { + public static final long ID = 54L; + + public long getID() { + return ID; + } + + public enum Attribute { + Bssid(0L), + SecurityType(1L), + WiFiVersion(2L), + ChannelNumber(3L), + Rssi(4L), + BeaconLostCount(5L), + BeaconRxCount(6L), + PacketMulticastRxCount(7L), + PacketMulticastTxCount(8L), + PacketUnicastRxCount(9L), + PacketUnicastTxCount(10L), + CurrentMaxRate(11L), + OverrunCount(12L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Disconnection(0L), + AssociationFailure(1L), + ConnectionStatus(2L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCounts(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class EthernetNetworkDiagnostics implements BaseCluster { + public static final long ID = 55L; + + public long getID() { + return ID; + } + + public enum Attribute { + PHYRate(0L), + FullDuplex(1L), + PacketRxCount(2L), + PacketTxCount(3L), + TxErrCount(4L), + CollisionCount(5L), + OverrunCount(6L), + CarrierDetect(7L), + TimeSinceReset(8L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCounts(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class TimeSynchronization implements BaseCluster { + public static final long ID = 56L; + + public long getID() { + return ID; + } + + public enum Attribute { + UTCTime(0L), + Granularity(1L), + TimeSource(2L), + TrustedTimeSource(3L), + DefaultNTP(4L), + TimeZone(5L), + DSTOffset(6L), + LocalTime(7L), + TimeZoneDatabase(8L), + NTPServerAvailable(9L), + TimeZoneListMaxSize(10L), + DSTOffsetListMaxSize(11L), + SupportsDNSResolve(12L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + DSTTableEmpty(0L), + DSTStatus(1L), + TimeZoneStatus(2L), + TimeFailure(3L), + MissingTrustedTimeSource(4L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SetUTCTime(0L), + SetTrustedTimeSource(1L), + SetTimeZone(2L), + SetDSTOffset(4L), + SetDefaultNTP(5L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetUTCTimeCommandField { + UTCTime(0), + Granularity(1), + TimeSource(2), + ; + private final int id; + + SetUTCTimeCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetUTCTimeCommandField value(int id) throws NoSuchFieldError { + for (SetUTCTimeCommandField field : SetUTCTimeCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetTrustedTimeSourceCommandField { + TrustedTimeSource(0), + ; + private final int id; + + SetTrustedTimeSourceCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetTrustedTimeSourceCommandField value(int id) throws NoSuchFieldError { + for (SetTrustedTimeSourceCommandField field : SetTrustedTimeSourceCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetTimeZoneCommandField { + TimeZone(0), + ; + private final int id; + + SetTimeZoneCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetTimeZoneCommandField value(int id) throws NoSuchFieldError { + for (SetTimeZoneCommandField field : SetTimeZoneCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetDSTOffsetCommandField { + DSTOffset(0), + ; + private final int id; + + SetDSTOffsetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetDSTOffsetCommandField value(int id) throws NoSuchFieldError { + for (SetDSTOffsetCommandField field : SetDSTOffsetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetDefaultNTPCommandField { + DefaultNTP(0), + ; + private final int id; + + SetDefaultNTPCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetDefaultNTPCommandField value(int id) throws NoSuchFieldError { + for (SetDefaultNTPCommandField field : SetDefaultNTPCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class BridgedDeviceBasicInformation implements BaseCluster { + public static final long ID = 57L; + + public long getID() { + return ID; + } + + public enum Attribute { + VendorName(1L), + VendorID(2L), + ProductName(3L), + NodeLabel(5L), + HardwareVersion(7L), + HardwareVersionString(8L), + SoftwareVersion(9L), + SoftwareVersionString(10L), + ManufacturingDate(11L), + PartNumber(12L), + ProductURL(13L), + ProductLabel(14L), + SerialNumber(15L), + Reachable(17L), + UniqueID(18L), + ProductAppearance(20L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StartUp(0L), + ShutDown(1L), + Leave(2L), + ReachableChanged(3L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Switch implements BaseCluster { + public static final long ID = 59L; + + public long getID() { + return ID; + } + + public enum Attribute { + NumberOfPositions(0L), + CurrentPosition(1L), + MultiPressMax(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SwitchLatched(0L), + InitialPress(1L), + LongPress(2L), + ShortRelease(3L), + LongRelease(4L), + MultiPressOngoing(5L), + MultiPressComplete(6L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class AdministratorCommissioning implements BaseCluster { + public static final long ID = 60L; + + public long getID() { + return ID; + } + + public enum Attribute { + WindowStatus(0L), + AdminFabricIndex(1L), + AdminVendorId(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + OpenCommissioningWindow(0L), + OpenBasicCommissioningWindow(1L), + RevokeCommissioning(2L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum OpenCommissioningWindowCommandField { + CommissioningTimeout(0), + PAKEPasscodeVerifier(1), + Discriminator(2), + Iterations(3), + Salt(4), + ; + private final int id; + + OpenCommissioningWindowCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static OpenCommissioningWindowCommandField value(int id) throws NoSuchFieldError { + for (OpenCommissioningWindowCommandField field : + OpenCommissioningWindowCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum OpenBasicCommissioningWindowCommandField { + CommissioningTimeout(0), + ; + private final int id; + + OpenBasicCommissioningWindowCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static OpenBasicCommissioningWindowCommandField value(int id) throws NoSuchFieldError { + for (OpenBasicCommissioningWindowCommandField field : + OpenBasicCommissioningWindowCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OperationalCredentials implements BaseCluster { + public static final long ID = 62L; + + public long getID() { + return ID; + } + + public enum Attribute { + NOCs(0L), + Fabrics(1L), + SupportedFabrics(2L), + CommissionedFabrics(3L), + TrustedRootCertificates(4L), + CurrentFabricIndex(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + AttestationRequest(0L), + CertificateChainRequest(2L), + CSRRequest(4L), + AddNOC(6L), + UpdateNOC(7L), + UpdateFabricLabel(9L), + RemoveFabric(10L), + AddTrustedRootCertificate(11L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AttestationRequestCommandField { + AttestationNonce(0), + ; + private final int id; + + AttestationRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AttestationRequestCommandField value(int id) throws NoSuchFieldError { + for (AttestationRequestCommandField field : AttestationRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum CertificateChainRequestCommandField { + CertificateType(0), + ; + private final int id; + + CertificateChainRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static CertificateChainRequestCommandField value(int id) throws NoSuchFieldError { + for (CertificateChainRequestCommandField field : + CertificateChainRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum CSRRequestCommandField { + CSRNonce(0), + IsForUpdateNOC(1), + ; + private final int id; + + CSRRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static CSRRequestCommandField value(int id) throws NoSuchFieldError { + for (CSRRequestCommandField field : CSRRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AddNOCCommandField { + NOCValue(0), + ICACValue(1), + IPKValue(2), + CaseAdminSubject(3), + AdminVendorId(4), + ; + private final int id; + + AddNOCCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddNOCCommandField value(int id) throws NoSuchFieldError { + for (AddNOCCommandField field : AddNOCCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum UpdateNOCCommandField { + NOCValue(0), + ICACValue(1), + ; + private final int id; + + UpdateNOCCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static UpdateNOCCommandField value(int id) throws NoSuchFieldError { + for (UpdateNOCCommandField field : UpdateNOCCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum UpdateFabricLabelCommandField { + Label(0), + ; + private final int id; + + UpdateFabricLabelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static UpdateFabricLabelCommandField value(int id) throws NoSuchFieldError { + for (UpdateFabricLabelCommandField field : UpdateFabricLabelCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum RemoveFabricCommandField { + FabricIndex(0), + ; + private final int id; + + RemoveFabricCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RemoveFabricCommandField value(int id) throws NoSuchFieldError { + for (RemoveFabricCommandField field : RemoveFabricCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum AddTrustedRootCertificateCommandField { + RootCACertificate(0), + ; + private final int id; + + AddTrustedRootCertificateCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static AddTrustedRootCertificateCommandField value(int id) throws NoSuchFieldError { + for (AddTrustedRootCertificateCommandField field : + AddTrustedRootCertificateCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class GroupKeyManagement implements BaseCluster { + public static final long ID = 63L; + + public long getID() { + return ID; + } + + public enum Attribute { + GroupKeyMap(0L), + GroupTable(1L), + MaxGroupsPerFabric(2L), + MaxGroupKeysPerFabric(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + KeySetWrite(0L), + KeySetRead(1L), + KeySetRemove(3L), + KeySetReadAllIndices(4L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum KeySetWriteCommandField { + GroupKeySet(0), + ; + private final int id; + + KeySetWriteCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static KeySetWriteCommandField value(int id) throws NoSuchFieldError { + for (KeySetWriteCommandField field : KeySetWriteCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum KeySetReadCommandField { + GroupKeySetID(0), + ; + private final int id; + + KeySetReadCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static KeySetReadCommandField value(int id) throws NoSuchFieldError { + for (KeySetReadCommandField field : KeySetReadCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum KeySetRemoveCommandField { + GroupKeySetID(0), + ; + private final int id; + + KeySetRemoveCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static KeySetRemoveCommandField value(int id) throws NoSuchFieldError { + for (KeySetRemoveCommandField field : KeySetRemoveCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum KeySetReadAllIndicesCommandField { + GroupKeySetIDs(0), + ; + private final int id; + + KeySetReadAllIndicesCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static KeySetReadAllIndicesCommandField value(int id) throws NoSuchFieldError { + for (KeySetReadAllIndicesCommandField field : KeySetReadAllIndicesCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class FixedLabel implements BaseCluster { + public static final long ID = 64L; + + public long getID() { + return ID; + } + + public enum Attribute { + LabelList(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class UserLabel implements BaseCluster { + public static final long ID = 65L; + + public long getID() { + return ID; + } + + public enum Attribute { + LabelList(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ProxyConfiguration implements BaseCluster { + public static final long ID = 66L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ProxyDiscovery implements BaseCluster { + public static final long ID = 67L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ProxyValid implements BaseCluster { + public static final long ID = 68L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class BooleanState implements BaseCluster { + public static final long ID = 69L; + + public long getID() { + return ID; + } + + public enum Attribute { + StateValue(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + StateChange(0L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class IcdManagement implements BaseCluster { + public static final long ID = 70L; + + public long getID() { + return ID; + } + + public enum Attribute { + IdleModeInterval(0L), + ActiveModeInterval(1L), + ActiveModeThreshold(2L), + RegisteredClients(3L), + ICDCounter(4L), + ClientsSupportedPerFabric(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + RegisterClient(0L), + UnregisterClient(2L), + StayActiveRequest(3L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum RegisterClientCommandField { + CheckInNodeID(0), + MonitoredSubject(1), + Key(2), + VerificationKey(3), + ; + private final int id; + + RegisterClientCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RegisterClientCommandField value(int id) throws NoSuchFieldError { + for (RegisterClientCommandField field : RegisterClientCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum UnregisterClientCommandField { + CheckInNodeID(0), + Key(1), + ; + private final int id; + + UnregisterClientCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static UnregisterClientCommandField value(int id) throws NoSuchFieldError { + for (UnregisterClientCommandField field : UnregisterClientCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ModeSelect implements BaseCluster { + public static final long ID = 80L; + + public long getID() { + return ID; + } + + public enum Attribute { + Description(0L), + StandardNamespace(1L), + SupportedModes(2L), + CurrentMode(3L), + StartUpMode(4L), + OnMode(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ChangeToMode(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ChangeToModeCommandField { + NewMode(0), + ; + private final int id; + + ChangeToModeCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ChangeToModeCommandField value(int id) throws NoSuchFieldError { + for (ChangeToModeCommandField field : ChangeToModeCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class TemperatureControl implements BaseCluster { + public static final long ID = 86L; + + public long getID() { + return ID; + } + + public enum Attribute { + TemperatureSetpoint(0L), + MinTemperature(1L), + MaxTemperature(2L), + Step(3L), + CurrentTemperatureLevelIndex(4L), + SupportedTemperatureLevels(5L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SetTemperature(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetTemperatureCommandField { + TargetTemperature(0), + TargetTemperatureLevel(1), + ; + private final int id; + + SetTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetTemperatureCommandField value(int id) throws NoSuchFieldError { + for (SetTemperatureCommandField field : SetTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class RefrigeratorAlarm implements BaseCluster { + public static final long ID = 87L; + + public long getID() { + return ID; + } + + public enum Attribute { + Mask(0L), + Latch(1L), + State(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Notify(0L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Reset(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ResetCommandField { + Alarms(0), + Mask(1), + ; + private final int id; + + ResetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ResetCommandField value(int id) throws NoSuchFieldError { + for (ResetCommandField field : ResetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class AirQuality implements BaseCluster { + public static final long ID = 91L; + + public long getID() { + return ID; + } + + public enum Attribute { + AirQuality(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class SmokeCoAlarm implements BaseCluster { + public static final long ID = 92L; + + public long getID() { + return ID; + } + + public enum Attribute { + ExpressedState(0L), + SmokeState(1L), + COState(2L), + BatteryAlert(3L), + DeviceMuted(4L), + TestInProgress(5L), + HardwareFaultAlert(6L), + EndOfServiceAlert(7L), + InterconnectSmokeAlarm(8L), + InterconnectCOAlarm(9L), + ContaminationState(10L), + SensitivityLevel(11L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SmokeAlarm(0L), + COAlarm(1L), + LowBattery(2L), + HardwareFault(3L), + EndOfService(4L), + SelfTestComplete(5L), + AlarmMuted(6L), + MuteEnded(7L), + InterconnectSmokeAlarm(8L), + InterconnectCOAlarm(9L), + AllClear(10L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SelfTestRequest(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class DishwasherAlarm implements BaseCluster { + public static final long ID = 93L; + + public long getID() { + return ID; + } + + public enum Attribute { + Mask(0L), + Latch(1L), + State(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + Notify(0L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + Reset(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ResetCommandField { + Alarms(0), + Mask(1), + ; + private final int id; + + ResetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ResetCommandField value(int id) throws NoSuchFieldError { + for (ResetCommandField field : ResetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class HepaFilterMonitoring implements BaseCluster { + public static final long ID = 113L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ActivatedCarbonFilterMonitoring implements BaseCluster { + public static final long ID = 114L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class CeramicFilterMonitoring implements BaseCluster { + public static final long ID = 115L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ElectrostaticFilterMonitoring implements BaseCluster { + public static final long ID = 116L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class UvFilterMonitoring implements BaseCluster { + public static final long ID = 117L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class IonizingFilterMonitoring implements BaseCluster { + public static final long ID = 118L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ZeoliteFilterMonitoring implements BaseCluster { + public static final long ID = 119L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OzoneFilterMonitoring implements BaseCluster { + public static final long ID = 120L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class WaterTankMonitoring implements BaseCluster { + public static final long ID = 121L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class FuelTankMonitoring implements BaseCluster { + public static final long ID = 122L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class InkCartridgeMonitoring implements BaseCluster { + public static final long ID = 123L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class TonerCartridgeMonitoring implements BaseCluster { + public static final long ID = 124L; + + public long getID() { + return ID; + } + + public enum Attribute { + Condition(0L), + DegradationDirection(1L), + ChangeIndication(2L), + InPlaceIndicator(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ResetCondition(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class DoorLock implements BaseCluster { + public static final long ID = 257L; + + public long getID() { + return ID; + } + + public enum Attribute { + LockState(0L), + LockType(1L), + ActuatorEnabled(2L), + DoorState(3L), + DoorOpenEvents(4L), + DoorClosedEvents(5L), + OpenPeriod(6L), + NumberOfTotalUsersSupported(17L), + NumberOfPINUsersSupported(18L), + NumberOfRFIDUsersSupported(19L), + NumberOfWeekDaySchedulesSupportedPerUser(20L), + NumberOfYearDaySchedulesSupportedPerUser(21L), + NumberOfHolidaySchedulesSupported(22L), + MaxPINCodeLength(23L), + MinPINCodeLength(24L), + MaxRFIDCodeLength(25L), + MinRFIDCodeLength(26L), + CredentialRulesSupport(27L), + NumberOfCredentialsSupportedPerUser(28L), + Language(33L), + LEDSettings(34L), + AutoRelockTime(35L), + SoundVolume(36L), + OperatingMode(37L), + SupportedOperatingModes(38L), + DefaultConfigurationRegister(39L), + EnableLocalProgramming(40L), + EnableOneTouchLocking(41L), + EnableInsideStatusLED(42L), + EnablePrivacyModeButton(43L), + LocalProgrammingFeatures(44L), + WrongCodeEntryLimit(48L), + UserCodeTemporaryDisableTime(49L), + SendPINOverTheAir(50L), + RequirePINforRemoteOperation(51L), + ExpiringUserTimeout(53L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + DoorLockAlarm(0L), + DoorStateChange(1L), + LockOperation(2L), + LockOperationError(3L), + LockUserChange(4L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + LockDoor(0L), + UnlockDoor(1L), + UnlockWithTimeout(3L), + SetWeekDaySchedule(11L), + GetWeekDaySchedule(12L), + ClearWeekDaySchedule(13L), + SetYearDaySchedule(14L), + GetYearDaySchedule(15L), + ClearYearDaySchedule(16L), + SetHolidaySchedule(17L), + GetHolidaySchedule(18L), + ClearHolidaySchedule(19L), + SetUser(26L), + GetUser(27L), + ClearUser(29L), + SetCredential(34L), + GetCredentialStatus(36L), + ClearCredential(38L), + UnboltDoor(39L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum LockDoorCommandField { + PINCode(0), + ; + private final int id; + + LockDoorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static LockDoorCommandField value(int id) throws NoSuchFieldError { + for (LockDoorCommandField field : LockDoorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum UnlockDoorCommandField { + PINCode(0), + ; + private final int id; + + UnlockDoorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static UnlockDoorCommandField value(int id) throws NoSuchFieldError { + for (UnlockDoorCommandField field : UnlockDoorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum UnlockWithTimeoutCommandField { + Timeout(0), + PINCode(1), + ; + private final int id; + + UnlockWithTimeoutCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static UnlockWithTimeoutCommandField value(int id) throws NoSuchFieldError { + for (UnlockWithTimeoutCommandField field : UnlockWithTimeoutCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetWeekDayScheduleCommandField { + WeekDayIndex(0), + UserIndex(1), + DaysMask(2), + StartHour(3), + StartMinute(4), + EndHour(5), + EndMinute(6), + ; + private final int id; + + SetWeekDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetWeekDayScheduleCommandField field : SetWeekDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetWeekDayScheduleCommandField { + WeekDayIndex(0), + UserIndex(1), + ; + private final int id; + + GetWeekDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetWeekDayScheduleCommandField field : GetWeekDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ClearWeekDayScheduleCommandField { + WeekDayIndex(0), + UserIndex(1), + ; + private final int id; + + ClearWeekDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ClearWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (ClearWeekDayScheduleCommandField field : ClearWeekDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetYearDayScheduleCommandField { + YearDayIndex(0), + UserIndex(1), + LocalStartTime(2), + LocalEndTime(3), + ; + private final int id; + + SetYearDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetYearDayScheduleCommandField field : SetYearDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetYearDayScheduleCommandField { + YearDayIndex(0), + UserIndex(1), + ; + private final int id; + + GetYearDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetYearDayScheduleCommandField field : GetYearDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ClearYearDayScheduleCommandField { + YearDayIndex(0), + UserIndex(1), + ; + private final int id; + + ClearYearDayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ClearYearDayScheduleCommandField value(int id) throws NoSuchFieldError { + for (ClearYearDayScheduleCommandField field : ClearYearDayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetHolidayScheduleCommandField { + HolidayIndex(0), + LocalStartTime(1), + LocalEndTime(2), + OperatingMode(3), + ; + private final int id; + + SetHolidayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetHolidayScheduleCommandField field : SetHolidayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetHolidayScheduleCommandField { + HolidayIndex(0), + ; + private final int id; + + GetHolidayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetHolidayScheduleCommandField field : GetHolidayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ClearHolidayScheduleCommandField { + HolidayIndex(0), + ; + private final int id; + + ClearHolidayScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ClearHolidayScheduleCommandField value(int id) throws NoSuchFieldError { + for (ClearHolidayScheduleCommandField field : ClearHolidayScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetUserCommandField { + OperationType(0), + UserIndex(1), + UserName(2), + UserUniqueID(3), + UserStatus(4), + UserType(5), + CredentialRule(6), + ; + private final int id; + + SetUserCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetUserCommandField value(int id) throws NoSuchFieldError { + for (SetUserCommandField field : SetUserCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetUserCommandField { + UserIndex(0), + ; + private final int id; + + GetUserCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetUserCommandField value(int id) throws NoSuchFieldError { + for (GetUserCommandField field : GetUserCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ClearUserCommandField { + UserIndex(0), + ; + private final int id; + + ClearUserCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ClearUserCommandField value(int id) throws NoSuchFieldError { + for (ClearUserCommandField field : ClearUserCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetCredentialCommandField { + OperationType(0), + Credential(1), + CredentialData(2), + UserIndex(3), + UserStatus(4), + UserType(5), + ; + private final int id; + + SetCredentialCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetCredentialCommandField value(int id) throws NoSuchFieldError { + for (SetCredentialCommandField field : SetCredentialCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetCredentialStatusCommandField { + Credential(0), + ; + private final int id; + + GetCredentialStatusCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetCredentialStatusCommandField value(int id) throws NoSuchFieldError { + for (GetCredentialStatusCommandField field : GetCredentialStatusCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ClearCredentialCommandField { + Credential(0), + ; + private final int id; + + ClearCredentialCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ClearCredentialCommandField value(int id) throws NoSuchFieldError { + for (ClearCredentialCommandField field : ClearCredentialCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum UnboltDoorCommandField { + PINCode(0), + ; + private final int id; + + UnboltDoorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static UnboltDoorCommandField value(int id) throws NoSuchFieldError { + for (UnboltDoorCommandField field : UnboltDoorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class WindowCovering implements BaseCluster { + public static final long ID = 258L; + + public long getID() { + return ID; + } + + public enum Attribute { + Type(0L), + PhysicalClosedLimitLift(1L), + PhysicalClosedLimitTilt(2L), + CurrentPositionLift(3L), + CurrentPositionTilt(4L), + NumberOfActuationsLift(5L), + NumberOfActuationsTilt(6L), + ConfigStatus(7L), + CurrentPositionLiftPercentage(8L), + CurrentPositionTiltPercentage(9L), + OperationalStatus(10L), + TargetPositionLiftPercent100ths(11L), + TargetPositionTiltPercent100ths(12L), + EndProductType(13L), + CurrentPositionLiftPercent100ths(14L), + CurrentPositionTiltPercent100ths(15L), + InstalledOpenLimitLift(16L), + InstalledClosedLimitLift(17L), + InstalledOpenLimitTilt(18L), + InstalledClosedLimitTilt(19L), + Mode(23L), + SafetyStatus(26L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + UpOrOpen(0L), + DownOrClose(1L), + StopMotion(2L), + GoToLiftValue(4L), + GoToLiftPercentage(5L), + GoToTiltValue(7L), + GoToTiltPercentage(8L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GoToLiftValueCommandField { + LiftValue(0), + ; + private final int id; + + GoToLiftValueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GoToLiftValueCommandField value(int id) throws NoSuchFieldError { + for (GoToLiftValueCommandField field : GoToLiftValueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GoToLiftPercentageCommandField { + LiftPercent100thsValue(0), + ; + private final int id; + + GoToLiftPercentageCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GoToLiftPercentageCommandField value(int id) throws NoSuchFieldError { + for (GoToLiftPercentageCommandField field : GoToLiftPercentageCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GoToTiltValueCommandField { + TiltValue(0), + ; + private final int id; + + GoToTiltValueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GoToTiltValueCommandField value(int id) throws NoSuchFieldError { + for (GoToTiltValueCommandField field : GoToTiltValueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GoToTiltPercentageCommandField { + TiltPercent100thsValue(0), + ; + private final int id; + + GoToTiltPercentageCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GoToTiltPercentageCommandField value(int id) throws NoSuchFieldError { + for (GoToTiltPercentageCommandField field : GoToTiltPercentageCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class BarrierControl implements BaseCluster { + public static final long ID = 259L; + + public long getID() { + return ID; + } + + public enum Attribute { + BarrierMovingState(1L), + BarrierSafetyStatus(2L), + BarrierCapabilities(3L), + BarrierOpenEvents(4L), + BarrierCloseEvents(5L), + BarrierCommandOpenEvents(6L), + BarrierCommandCloseEvents(7L), + BarrierOpenPeriod(8L), + BarrierClosePeriod(9L), + BarrierPosition(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + BarrierControlGoToPercent(0L), + BarrierControlStop(1L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum BarrierControlGoToPercentCommandField { + PercentOpen(0), + ; + private final int id; + + BarrierControlGoToPercentCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static BarrierControlGoToPercentCommandField value(int id) throws NoSuchFieldError { + for (BarrierControlGoToPercentCommandField field : + BarrierControlGoToPercentCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class PumpConfigurationAndControl implements BaseCluster { + public static final long ID = 512L; + + public long getID() { + return ID; + } + + public enum Attribute { + MaxPressure(0L), + MaxSpeed(1L), + MaxFlow(2L), + MinConstPressure(3L), + MaxConstPressure(4L), + MinCompPressure(5L), + MaxCompPressure(6L), + MinConstSpeed(7L), + MaxConstSpeed(8L), + MinConstFlow(9L), + MaxConstFlow(10L), + MinConstTemp(11L), + MaxConstTemp(12L), + PumpStatus(16L), + EffectiveOperationMode(17L), + EffectiveControlMode(18L), + Capacity(19L), + Speed(20L), + LifetimeRunningHours(21L), + Power(22L), + LifetimeEnergyConsumed(23L), + OperationMode(32L), + ControlMode(33L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + SupplyVoltageLow(0L), + SupplyVoltageHigh(1L), + PowerMissingPhase(2L), + SystemPressureLow(3L), + SystemPressureHigh(4L), + DryRunning(5L), + MotorTemperatureHigh(6L), + PumpMotorFatalFailure(7L), + ElectronicTemperatureHigh(8L), + PumpBlocked(9L), + SensorFailure(10L), + ElectronicNonFatalFailure(11L), + ElectronicFatalFailure(12L), + GeneralFault(13L), + Leakage(14L), + AirDetection(15L), + TurbineOperation(16L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Thermostat implements BaseCluster { + public static final long ID = 513L; + + public long getID() { + return ID; + } + + public enum Attribute { + LocalTemperature(0L), + OutdoorTemperature(1L), + Occupancy(2L), + AbsMinHeatSetpointLimit(3L), + AbsMaxHeatSetpointLimit(4L), + AbsMinCoolSetpointLimit(5L), + AbsMaxCoolSetpointLimit(6L), + PICoolingDemand(7L), + PIHeatingDemand(8L), + HVACSystemTypeConfiguration(9L), + LocalTemperatureCalibration(16L), + OccupiedCoolingSetpoint(17L), + OccupiedHeatingSetpoint(18L), + UnoccupiedCoolingSetpoint(19L), + UnoccupiedHeatingSetpoint(20L), + MinHeatSetpointLimit(21L), + MaxHeatSetpointLimit(22L), + MinCoolSetpointLimit(23L), + MaxCoolSetpointLimit(24L), + MinSetpointDeadBand(25L), + RemoteSensing(26L), + ControlSequenceOfOperation(27L), + SystemMode(28L), + ThermostatRunningMode(30L), + StartOfWeek(32L), + NumberOfWeeklyTransitions(33L), + NumberOfDailyTransitions(34L), + TemperatureSetpointHold(35L), + TemperatureSetpointHoldDuration(36L), + ThermostatProgrammingOperationMode(37L), + ThermostatRunningState(41L), + SetpointChangeSource(48L), + SetpointChangeAmount(49L), + SetpointChangeSourceTimestamp(50L), + OccupiedSetback(52L), + OccupiedSetbackMin(53L), + OccupiedSetbackMax(54L), + UnoccupiedSetback(55L), + UnoccupiedSetbackMin(56L), + UnoccupiedSetbackMax(57L), + EmergencyHeatDelta(58L), + ACType(64L), + ACCapacity(65L), + ACRefrigerantType(66L), + ACCompressorType(67L), + ACErrorCode(68L), + ACLouverPosition(69L), + ACCoilTemperature(70L), + ACCapacityformat(71L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + SetpointRaiseLower(0L), + SetWeeklySchedule(1L), + GetWeeklySchedule(2L), + ClearWeeklySchedule(3L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetpointRaiseLowerCommandField { + Mode(0), + Amount(1), + ; + private final int id; + + SetpointRaiseLowerCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetpointRaiseLowerCommandField value(int id) throws NoSuchFieldError { + for (SetpointRaiseLowerCommandField field : SetpointRaiseLowerCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SetWeeklyScheduleCommandField { + NumberOfTransitionsForSequence(0), + DayOfWeekForSequence(1), + ModeForSequence(2), + Transitions(3), + ; + private final int id; + + SetWeeklyScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { + for (SetWeeklyScheduleCommandField field : SetWeeklyScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetWeeklyScheduleCommandField { + DaysToReturn(0), + ModeToReturn(1), + ; + private final int id; + + GetWeeklyScheduleCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { + for (GetWeeklyScheduleCommandField field : GetWeeklyScheduleCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class FanControl implements BaseCluster { + public static final long ID = 514L; + + public long getID() { + return ID; + } + + public enum Attribute { + FanMode(0L), + FanModeSequence(1L), + PercentSetting(2L), + PercentCurrent(3L), + SpeedMax(4L), + SpeedSetting(5L), + SpeedCurrent(6L), + RockSupport(7L), + RockSetting(8L), + WindSupport(9L), + WindSetting(10L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ThermostatUserInterfaceConfiguration implements BaseCluster { + public static final long ID = 516L; + + public long getID() { + return ID; + } + + public enum Attribute { + TemperatureDisplayMode(0L), + KeypadLockout(1L), + ScheduleProgrammingVisibility(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ColorControl implements BaseCluster { + public static final long ID = 768L; + + public long getID() { + return ID; + } + + public enum Attribute { + CurrentHue(0L), + CurrentSaturation(1L), + RemainingTime(2L), + CurrentX(3L), + CurrentY(4L), + DriftCompensation(5L), + CompensationText(6L), + ColorTemperatureMireds(7L), + ColorMode(8L), + Options(15L), + NumberOfPrimaries(16L), + Primary1X(17L), + Primary1Y(18L), + Primary1Intensity(19L), + Primary2X(21L), + Primary2Y(22L), + Primary2Intensity(23L), + Primary3X(25L), + Primary3Y(26L), + Primary3Intensity(27L), + Primary4X(32L), + Primary4Y(33L), + Primary4Intensity(34L), + Primary5X(36L), + Primary5Y(37L), + Primary5Intensity(38L), + Primary6X(40L), + Primary6Y(41L), + Primary6Intensity(42L), + WhitePointX(48L), + WhitePointY(49L), + ColorPointRX(50L), + ColorPointRY(51L), + ColorPointRIntensity(52L), + ColorPointGX(54L), + ColorPointGY(55L), + ColorPointGIntensity(56L), + ColorPointBX(58L), + ColorPointBY(59L), + ColorPointBIntensity(60L), + EnhancedCurrentHue(16384L), + EnhancedColorMode(16385L), + ColorLoopActive(16386L), + ColorLoopDirection(16387L), + ColorLoopTime(16388L), + ColorLoopStartEnhancedHue(16389L), + ColorLoopStoredEnhancedHue(16390L), + ColorCapabilities(16394L), + ColorTempPhysicalMinMireds(16395L), + ColorTempPhysicalMaxMireds(16396L), + CoupleColorTempToLevelMinMireds(16397L), + StartUpColorTemperatureMireds(16400L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Command { + MoveToHue(0L), + MoveHue(1L), + StepHue(2L), + MoveToSaturation(3L), + MoveSaturation(4L), + StepSaturation(5L), + MoveToHueAndSaturation(6L), + MoveToColor(7L), + MoveColor(8L), + StepColor(9L), + MoveToColorTemperature(10L), + EnhancedMoveToHue(64L), + EnhancedMoveHue(65L), + EnhancedStepHue(66L), + EnhancedMoveToHueAndSaturation(67L), + ColorLoopSet(68L), + StopMoveStep(71L), + MoveColorTemperature(75L), + StepColorTemperature(76L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToHueCommandField { + Hue(0), + Direction(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + MoveToHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToHueCommandField value(int id) throws NoSuchFieldError { + for (MoveToHueCommandField field : MoveToHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveHueCommandField { + MoveMode(0), + Rate(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveHueCommandField value(int id) throws NoSuchFieldError { + for (MoveHueCommandField field : MoveHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StepHueCommandField { + StepMode(0), + StepSize(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + StepHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StepHueCommandField value(int id) throws NoSuchFieldError { + for (StepHueCommandField field : StepHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToSaturationCommandField { + Saturation(0), + TransitionTime(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveToSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToSaturationCommandField value(int id) throws NoSuchFieldError { + for (MoveToSaturationCommandField field : MoveToSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveSaturationCommandField { + MoveMode(0), + Rate(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveSaturationCommandField value(int id) throws NoSuchFieldError { + for (MoveSaturationCommandField field : MoveSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StepSaturationCommandField { + StepMode(0), + StepSize(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + StepSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StepSaturationCommandField value(int id) throws NoSuchFieldError { + for (StepSaturationCommandField field : StepSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToHueAndSaturationCommandField { + Hue(0), + Saturation(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + MoveToHueAndSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToHueAndSaturationCommandField value(int id) throws NoSuchFieldError { + for (MoveToHueAndSaturationCommandField field : + MoveToHueAndSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToColorCommandField { + ColorX(0), + ColorY(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + MoveToColorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToColorCommandField value(int id) throws NoSuchFieldError { + for (MoveToColorCommandField field : MoveToColorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveColorCommandField { + RateX(0), + RateY(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveColorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveColorCommandField value(int id) throws NoSuchFieldError { + for (MoveColorCommandField field : MoveColorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StepColorCommandField { + StepX(0), + StepY(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + StepColorCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StepColorCommandField value(int id) throws NoSuchFieldError { + for (StepColorCommandField field : StepColorCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveToColorTemperatureCommandField { + ColorTemperatureMireds(0), + TransitionTime(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + MoveToColorTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveToColorTemperatureCommandField value(int id) throws NoSuchFieldError { + for (MoveToColorTemperatureCommandField field : + MoveToColorTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnhancedMoveToHueCommandField { + EnhancedHue(0), + Direction(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + EnhancedMoveToHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnhancedMoveToHueCommandField value(int id) throws NoSuchFieldError { + for (EnhancedMoveToHueCommandField field : EnhancedMoveToHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnhancedMoveHueCommandField { + MoveMode(0), + Rate(1), + OptionsMask(2), + OptionsOverride(3), + ; + private final int id; + + EnhancedMoveHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnhancedMoveHueCommandField value(int id) throws NoSuchFieldError { + for (EnhancedMoveHueCommandField field : EnhancedMoveHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnhancedStepHueCommandField { + StepMode(0), + StepSize(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + EnhancedStepHueCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnhancedStepHueCommandField value(int id) throws NoSuchFieldError { + for (EnhancedStepHueCommandField field : EnhancedStepHueCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum EnhancedMoveToHueAndSaturationCommandField { + EnhancedHue(0), + Saturation(1), + TransitionTime(2), + OptionsMask(3), + OptionsOverride(4), + ; + private final int id; + + EnhancedMoveToHueAndSaturationCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static EnhancedMoveToHueAndSaturationCommandField value(int id) + throws NoSuchFieldError { + for (EnhancedMoveToHueAndSaturationCommandField field : + EnhancedMoveToHueAndSaturationCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ColorLoopSetCommandField { + UpdateFlags(0), + Action(1), + Direction(2), + Time(3), + StartHue(4), + OptionsMask(5), + OptionsOverride(6), + ; + private final int id; + + ColorLoopSetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ColorLoopSetCommandField value(int id) throws NoSuchFieldError { + for (ColorLoopSetCommandField field : ColorLoopSetCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StopMoveStepCommandField { + OptionsMask(0), + OptionsOverride(1), + ; + private final int id; + + StopMoveStepCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StopMoveStepCommandField value(int id) throws NoSuchFieldError { + for (StopMoveStepCommandField field : StopMoveStepCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum MoveColorTemperatureCommandField { + MoveMode(0), + Rate(1), + ColorTemperatureMinimumMireds(2), + ColorTemperatureMaximumMireds(3), + OptionsMask(4), + OptionsOverride(5), + ; + private final int id; + + MoveColorTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static MoveColorTemperatureCommandField value(int id) throws NoSuchFieldError { + for (MoveColorTemperatureCommandField field : MoveColorTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum StepColorTemperatureCommandField { + StepMode(0), + StepSize(1), + TransitionTime(2), + ColorTemperatureMinimumMireds(3), + ColorTemperatureMaximumMireds(4), + OptionsMask(5), + OptionsOverride(6), + ; + private final int id; + + StepColorTemperatureCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StepColorTemperatureCommandField value(int id) throws NoSuchFieldError { + for (StepColorTemperatureCommandField field : StepColorTemperatureCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class BallastConfiguration implements BaseCluster { + public static final long ID = 769L; + + public long getID() { + return ID; + } + + public enum Attribute { + PhysicalMinLevel(0L), + PhysicalMaxLevel(1L), + BallastStatus(2L), + MinLevel(16L), + MaxLevel(17L), + IntrinsicBallastFactor(20L), + BallastFactorAdjustment(21L), + LampQuantity(32L), + LampType(48L), + LampManufacturer(49L), + LampRatedHours(50L), + LampBurnHours(51L), + LampAlarmMode(52L), + LampBurnHoursTripPoint(53L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == SoftwareDiagnostics.ID) { - return new SoftwareDiagnostics(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == ThreadNetworkDiagnostics.ID) { - return new ThreadNetworkDiagnostics(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class IlluminanceMeasurement implements BaseCluster { + public static final long ID = 1024L; + + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + LightSensorType(4L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == WiFiNetworkDiagnostics.ID) { - return new WiFiNetworkDiagnostics(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == EthernetNetworkDiagnostics.ID) { - return new EthernetNetworkDiagnostics(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class TemperatureMeasurement implements BaseCluster { + public static final long ID = 1026L; + + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == TimeSynchronization.ID) { - return new TimeSynchronization(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == BridgedDeviceBasicInformation.ID) { - return new BridgedDeviceBasicInformation(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class PressureMeasurement implements BaseCluster { + public static final long ID = 1027L; + + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + ScaledValue(16L), + MinScaledValue(17L), + MaxScaledValue(18L), + ScaledTolerance(19L), + Scale(20L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == Switch.ID) { - return new Switch(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == AdministratorCommissioning.ID) { - return new AdministratorCommissioning(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class FlowMeasurement implements BaseCluster { + public static final long ID = 1028L; + + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == OperationalCredentials.ID) { - return new OperationalCredentials(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == GroupKeyManagement.ID) { - return new GroupKeyManagement(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class RelativeHumidityMeasurement implements BaseCluster { + public static final long ID = 1029L; + + public long getID() { + return ID; + } + + public enum Attribute { + MeasuredValue(0L), + MinMeasuredValue(1L), + MaxMeasuredValue(2L), + Tolerance(3L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == FixedLabel.ID) { - return new FixedLabel(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == UserLabel.ID) { - return new UserLabel(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class OccupancySensing implements BaseCluster { + public static final long ID = 1030L; + + public long getID() { + return ID; + } + + public enum Attribute { + Occupancy(0L), + OccupancySensorType(1L), + OccupancySensorTypeBitmap(2L), + PIROccupiedToUnoccupiedDelay(16L), + PIRUnoccupiedToOccupiedDelay(17L), + PIRUnoccupiedToOccupiedThreshold(18L), + UltrasonicOccupiedToUnoccupiedDelay(32L), + UltrasonicUnoccupiedToOccupiedDelay(33L), + UltrasonicUnoccupiedToOccupiedThreshold(34L), + PhysicalContactOccupiedToUnoccupiedDelay(48L), + PhysicalContactUnoccupiedToOccupiedDelay(49L), + PhysicalContactUnoccupiedToOccupiedThreshold(50L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == ProxyConfiguration.ID) { - return new ProxyConfiguration(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == ProxyDiscovery.ID) { - return new ProxyDiscovery(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class WakeOnLan implements BaseCluster { + public static final long ID = 1283L; + + public long getID() { + return ID; + } + + public enum Attribute { + MACAddress(0L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == ProxyValid.ID) { - return new ProxyValid(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == BooleanState.ID) { - return new BooleanState(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class Channel implements BaseCluster { + public static final long ID = 1284L; + + public long getID() { + return ID; + } + + public enum Attribute { + ChannelList(0L), + Lineup(1L), + CurrentChannel(2L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == IcdManagement.ID) { - return new IcdManagement(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ChangeChannel(0L), + ChangeChannelByNumber(2L), + SkipChannel(3L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum ChangeChannelCommandField { + Match(0), + ; + private final int id; + + ChangeChannelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ChangeChannelCommandField value(int id) throws NoSuchFieldError { + for (ChangeChannelCommandField field : ChangeChannelCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ModeSelect.ID) { - return new ModeSelect(); + throw new NoSuchFieldError(); + } + } + + public enum ChangeChannelByNumberCommandField { + MajorNumber(0), + MinorNumber(1), + ; + private final int id; + + ChangeChannelByNumberCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static ChangeChannelByNumberCommandField value(int id) throws NoSuchFieldError { + for (ChangeChannelByNumberCommandField field : ChangeChannelByNumberCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == TemperatureControl.ID) { - return new TemperatureControl(); + throw new NoSuchFieldError(); + } + } + + public enum SkipChannelCommandField { + Count(0), + ; + private final int id; + + SkipChannelCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SkipChannelCommandField value(int id) throws NoSuchFieldError { + for (SkipChannelCommandField field : SkipChannelCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == RefrigeratorAlarm.ID) { - return new RefrigeratorAlarm(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class TargetNavigator implements BaseCluster { + public static final long ID = 1285L; + + public long getID() { + return ID; + } + + public enum Attribute { + TargetList(0L), + CurrentTarget(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == AirQuality.ID) { - return new AirQuality(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + NavigateTarget(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == SmokeCoAlarm.ID) { - return new SmokeCoAlarm(); + throw new NoSuchFieldError(); + } + } + + public enum NavigateTargetCommandField { + Target(0), + Data(1), + ; + private final int id; + + NavigateTargetCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static NavigateTargetCommandField value(int id) throws NoSuchFieldError { + for (NavigateTargetCommandField field : NavigateTargetCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == DishwasherAlarm.ID) { - return new DishwasherAlarm(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class MediaPlayback implements BaseCluster { + public static final long ID = 1286L; + + public long getID() { + return ID; + } + + public enum Attribute { + CurrentState(0L), + StartTime(1L), + Duration(2L), + SampledPosition(3L), + PlaybackSpeed(4L), + SeekRangeEnd(5L), + SeekRangeStart(6L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == HepaFilterMonitoring.ID) { - return new HepaFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + Play(0L), + Pause(1L), + Stop(2L), + StartOver(3L), + Previous(4L), + Next(5L), + Rewind(6L), + FastForward(7L), + SkipForward(8L), + SkipBackward(9L), + Seek(11L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SkipForwardCommandField { + DeltaPositionMilliseconds(0), + ; + private final int id; + + SkipForwardCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SkipForwardCommandField value(int id) throws NoSuchFieldError { + for (SkipForwardCommandField field : SkipForwardCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ActivatedCarbonFilterMonitoring.ID) { - return new ActivatedCarbonFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum SkipBackwardCommandField { + DeltaPositionMilliseconds(0), + ; + private final int id; + + SkipBackwardCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SkipBackwardCommandField value(int id) throws NoSuchFieldError { + for (SkipBackwardCommandField field : SkipBackwardCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == CeramicFilterMonitoring.ID) { - return new CeramicFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum SeekCommandField { + Position(0), + ; + private final int id; + + SeekCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SeekCommandField value(int id) throws NoSuchFieldError { + for (SeekCommandField field : SeekCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ElectrostaticFilterMonitoring.ID) { - return new ElectrostaticFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class MediaInput implements BaseCluster { + public static final long ID = 1287L; + + public long getID() { + return ID; + } + + public enum Attribute { + InputList(0L), + CurrentInput(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == UvFilterMonitoring.ID) { - return new UvFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + SelectInput(0L), + ShowInputStatus(1L), + HideInputStatus(2L), + RenameInput(3L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SelectInputCommandField { + Index(0), + ; + private final int id; + + SelectInputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SelectInputCommandField value(int id) throws NoSuchFieldError { + for (SelectInputCommandField field : SelectInputCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == IonizingFilterMonitoring.ID) { - return new IonizingFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum RenameInputCommandField { + Index(0), + Name(1), + ; + private final int id; + + RenameInputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RenameInputCommandField value(int id) throws NoSuchFieldError { + for (RenameInputCommandField field : RenameInputCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ZeoliteFilterMonitoring.ID) { - return new ZeoliteFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class LowPower implements BaseCluster { + public static final long ID = 1288L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == OzoneFilterMonitoring.ID) { - return new OzoneFilterMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + Sleep(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == WaterTankMonitoring.ID) { - return new WaterTankMonitoring(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class KeypadInput implements BaseCluster { + public static final long ID = 1289L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == FuelTankMonitoring.ID) { - return new FuelTankMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + SendKey(0L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == InkCartridgeMonitoring.ID) { - return new InkCartridgeMonitoring(); + throw new NoSuchFieldError(); + } + } + + public enum SendKeyCommandField { + KeyCode(0), + ; + private final int id; + + SendKeyCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SendKeyCommandField value(int id) throws NoSuchFieldError { + for (SendKeyCommandField field : SendKeyCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == TonerCartridgeMonitoring.ID) { - return new TonerCartridgeMonitoring(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ContentLauncher implements BaseCluster { + public static final long ID = 1290L; + + public long getID() { + return ID; + } + + public enum Attribute { + AcceptHeader(0L), + SupportedStreamingProtocols(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == DoorLock.ID) { - return new DoorLock(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + LaunchContent(0L), + LaunchURL(1L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == WindowCovering.ID) { - return new WindowCovering(); + throw new NoSuchFieldError(); + } + } + + public enum LaunchContentCommandField { + Search(0), + AutoPlay(1), + Data(2), + ; + private final int id; + + LaunchContentCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static LaunchContentCommandField value(int id) throws NoSuchFieldError { + for (LaunchContentCommandField field : LaunchContentCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum LaunchURLCommandField { + ContentURL(0), + DisplayString(1), + BrandingInformation(2), + ; + private final int id; + + LaunchURLCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static LaunchURLCommandField value(int id) throws NoSuchFieldError { + for (LaunchURLCommandField field : LaunchURLCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class AudioOutput implements BaseCluster { + public static final long ID = 1291L; + + public long getID() { + return ID; + } + + public enum Attribute { + OutputList(0L), + CurrentOutput(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == BarrierControl.ID) { - return new BarrierControl(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + SelectOutput(0L), + RenameOutput(1L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == PumpConfigurationAndControl.ID) { - return new PumpConfigurationAndControl(); + throw new NoSuchFieldError(); + } + } + + public enum SelectOutputCommandField { + Index(0), + ; + private final int id; + + SelectOutputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SelectOutputCommandField value(int id) throws NoSuchFieldError { + for (SelectOutputCommandField field : SelectOutputCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == Thermostat.ID) { - return new Thermostat(); + throw new NoSuchFieldError(); + } + } + + public enum RenameOutputCommandField { + Index(0), + Name(1), + ; + private final int id; + + RenameOutputCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static RenameOutputCommandField value(int id) throws NoSuchFieldError { + for (RenameOutputCommandField field : RenameOutputCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == FanControl.ID) { - return new FanControl(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ApplicationLauncher implements BaseCluster { + public static final long ID = 1292L; + + public long getID() { + return ID; + } + + public enum Attribute { + CatalogList(0L), + CurrentApp(1L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == ThermostatUserInterfaceConfiguration.ID) { - return new ThermostatUserInterfaceConfiguration(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + LaunchApp(0L), + StopApp(1L), + HideApp(2L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum LaunchAppCommandField { + Application(0), + Data(1), + ; + private final int id; + + LaunchAppCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static LaunchAppCommandField value(int id) throws NoSuchFieldError { + for (LaunchAppCommandField field : LaunchAppCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ColorControl.ID) { - return new ColorControl(); + throw new NoSuchFieldError(); + } + } + + public enum StopAppCommandField { + Application(0), + ; + private final int id; + + StopAppCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static StopAppCommandField value(int id) throws NoSuchFieldError { + for (StopAppCommandField field : StopAppCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == BallastConfiguration.ID) { - return new BallastConfiguration(); + throw new NoSuchFieldError(); + } + } + + public enum HideAppCommandField { + Application(0), + ; + private final int id; + + HideAppCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static HideAppCommandField value(int id) throws NoSuchFieldError { + for (HideAppCommandField field : HideAppCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == IlluminanceMeasurement.ID) { - return new IlluminanceMeasurement(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ApplicationBasic implements BaseCluster { + public static final long ID = 1293L; + + public long getID() { + return ID; + } + + public enum Attribute { + VendorName(0L), + VendorID(1L), + ApplicationName(2L), + ProductID(3L), + Application(4L), + Status(5L), + ApplicationVersion(6L), + AllowedVendorList(7L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == TemperatureMeasurement.ID) { - return new TemperatureMeasurement(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == PressureMeasurement.ID) { - return new PressureMeasurement(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class AccountLogin implements BaseCluster { + public static final long ID = 1294L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == FlowMeasurement.ID) { - return new FlowMeasurement(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + GetSetupPIN(0L), + Login(2L), + Logout(3L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum GetSetupPINCommandField { + TempAccountIdentifier(0), + ; + private final int id; + + GetSetupPINCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetSetupPINCommandField value(int id) throws NoSuchFieldError { + for (GetSetupPINCommandField field : GetSetupPINCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == RelativeHumidityMeasurement.ID) { - return new RelativeHumidityMeasurement(); + throw new NoSuchFieldError(); + } + } + + public enum LoginCommandField { + TempAccountIdentifier(0), + SetupPIN(1), + ; + private final int id; + + LoginCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static LoginCommandField value(int id) throws NoSuchFieldError { + for (LoginCommandField field : LoginCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == OccupancySensing.ID) { - return new OccupancySensing(); + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class ElectricalMeasurement implements BaseCluster { + public static final long ID = 2820L; + + public long getID() { + return ID; + } + + public enum Attribute { + MeasurementType(0L), + DcVoltage(256L), + DcVoltageMin(257L), + DcVoltageMax(258L), + DcCurrent(259L), + DcCurrentMin(260L), + DcCurrentMax(261L), + DcPower(262L), + DcPowerMin(263L), + DcPowerMax(264L), + DcVoltageMultiplier(512L), + DcVoltageDivisor(513L), + DcCurrentMultiplier(514L), + DcCurrentDivisor(515L), + DcPowerMultiplier(516L), + DcPowerDivisor(517L), + AcFrequency(768L), + AcFrequencyMin(769L), + AcFrequencyMax(770L), + NeutralCurrent(771L), + TotalActivePower(772L), + TotalReactivePower(773L), + TotalApparentPower(774L), + Measured1stHarmonicCurrent(775L), + Measured3rdHarmonicCurrent(776L), + Measured5thHarmonicCurrent(777L), + Measured7thHarmonicCurrent(778L), + Measured9thHarmonicCurrent(779L), + Measured11thHarmonicCurrent(780L), + MeasuredPhase1stHarmonicCurrent(781L), + MeasuredPhase3rdHarmonicCurrent(782L), + MeasuredPhase5thHarmonicCurrent(783L), + MeasuredPhase7thHarmonicCurrent(784L), + MeasuredPhase9thHarmonicCurrent(785L), + MeasuredPhase11thHarmonicCurrent(786L), + AcFrequencyMultiplier(1024L), + AcFrequencyDivisor(1025L), + PowerMultiplier(1026L), + PowerDivisor(1027L), + HarmonicCurrentMultiplier(1028L), + PhaseHarmonicCurrentMultiplier(1029L), + InstantaneousVoltage(1280L), + InstantaneousLineCurrent(1281L), + InstantaneousActiveCurrent(1282L), + InstantaneousReactiveCurrent(1283L), + InstantaneousPower(1284L), + RmsVoltage(1285L), + RmsVoltageMin(1286L), + RmsVoltageMax(1287L), + RmsCurrent(1288L), + RmsCurrentMin(1289L), + RmsCurrentMax(1290L), + ActivePower(1291L), + ActivePowerMin(1292L), + ActivePowerMax(1293L), + ReactivePower(1294L), + ApparentPower(1295L), + PowerFactor(1296L), + AverageRmsVoltageMeasurementPeriod(1297L), + AverageRmsUnderVoltageCounter(1299L), + RmsExtremeOverVoltagePeriod(1300L), + RmsExtremeUnderVoltagePeriod(1301L), + RmsVoltageSagPeriod(1302L), + RmsVoltageSwellPeriod(1303L), + AcVoltageMultiplier(1536L), + AcVoltageDivisor(1537L), + AcCurrentMultiplier(1538L), + AcCurrentDivisor(1539L), + AcPowerMultiplier(1540L), + AcPowerDivisor(1541L), + OverloadAlarmsMask(1792L), + VoltageOverload(1793L), + CurrentOverload(1794L), + AcOverloadAlarmsMask(2048L), + AcVoltageOverload(2049L), + AcCurrentOverload(2050L), + AcActivePowerOverload(2051L), + AcReactivePowerOverload(2052L), + AverageRmsOverVoltage(2053L), + AverageRmsUnderVoltage(2054L), + RmsExtremeOverVoltage(2055L), + RmsExtremeUnderVoltage(2056L), + RmsVoltageSag(2057L), + RmsVoltageSwell(2058L), + LineCurrentPhaseB(2305L), + ActiveCurrentPhaseB(2306L), + ReactiveCurrentPhaseB(2307L), + RmsVoltagePhaseB(2309L), + RmsVoltageMinPhaseB(2310L), + RmsVoltageMaxPhaseB(2311L), + RmsCurrentPhaseB(2312L), + RmsCurrentMinPhaseB(2313L), + RmsCurrentMaxPhaseB(2314L), + ActivePowerPhaseB(2315L), + ActivePowerMinPhaseB(2316L), + ActivePowerMaxPhaseB(2317L), + ReactivePowerPhaseB(2318L), + ApparentPowerPhaseB(2319L), + PowerFactorPhaseB(2320L), + AverageRmsVoltageMeasurementPeriodPhaseB(2321L), + AverageRmsOverVoltageCounterPhaseB(2322L), + AverageRmsUnderVoltageCounterPhaseB(2323L), + RmsExtremeOverVoltagePeriodPhaseB(2324L), + RmsExtremeUnderVoltagePeriodPhaseB(2325L), + RmsVoltageSagPeriodPhaseB(2326L), + RmsVoltageSwellPeriodPhaseB(2327L), + LineCurrentPhaseC(2561L), + ActiveCurrentPhaseC(2562L), + ReactiveCurrentPhaseC(2563L), + RmsVoltagePhaseC(2565L), + RmsVoltageMinPhaseC(2566L), + RmsVoltageMaxPhaseC(2567L), + RmsCurrentPhaseC(2568L), + RmsCurrentMinPhaseC(2569L), + RmsCurrentMaxPhaseC(2570L), + ActivePowerPhaseC(2571L), + ActivePowerMinPhaseC(2572L), + ActivePowerMaxPhaseC(2573L), + ReactivePowerPhaseC(2574L), + ApparentPowerPhaseC(2575L), + PowerFactorPhaseC(2576L), + AverageRmsVoltageMeasurementPeriodPhaseC(2577L), + AverageRmsOverVoltageCounterPhaseC(2578L), + AverageRmsUnderVoltageCounterPhaseC(2579L), + RmsExtremeOverVoltagePeriodPhaseC(2580L), + RmsExtremeUnderVoltagePeriodPhaseC(2581L), + RmsVoltageSagPeriodPhaseC(2582L), + RmsVoltageSwellPeriodPhaseC(2583L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == WakeOnLan.ID) { - return new WakeOnLan(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + GetProfileInfoCommand(0L), + GetMeasurementProfileCommand(1L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == Channel.ID) { - return new Channel(); + throw new NoSuchFieldError(); + } + } + + public enum GetMeasurementProfileCommandCommandField { + AttributeId(0), + StartTime(1), + NumberOfIntervals(2), + ; + private final int id; + + GetMeasurementProfileCommandCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static GetMeasurementProfileCommandCommandField value(int id) throws NoSuchFieldError { + for (GetMeasurementProfileCommandCommandField field : + GetMeasurementProfileCommandCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class UnitTesting implements BaseCluster { + public static final long ID = 4294048773L; + + public long getID() { + return ID; + } + + public enum Attribute { + Boolean(0L), + Bitmap8(1L), + Bitmap16(2L), + Bitmap32(3L), + Bitmap64(4L), + Int8u(5L), + Int16u(6L), + Int24u(7L), + Int32u(8L), + Int40u(9L), + Int48u(10L), + Int56u(11L), + Int64u(12L), + Int8s(13L), + Int16s(14L), + Int24s(15L), + Int32s(16L), + Int40s(17L), + Int48s(18L), + Int56s(19L), + Int64s(20L), + Enum8(21L), + Enum16(22L), + FloatSingle(23L), + FloatDouble(24L), + OctetString(25L), + ListInt8u(26L), + ListOctetString(27L), + ListStructOctetString(28L), + LongOctetString(29L), + CharString(30L), + LongCharString(31L), + EpochUs(32L), + EpochS(33L), + VendorId(34L), + ListNullablesAndOptionalsStruct(35L), + EnumAttr(36L), + StructAttr(37L), + RangeRestrictedInt8u(38L), + RangeRestrictedInt8s(39L), + RangeRestrictedInt16u(40L), + RangeRestrictedInt16s(41L), + ListLongOctetString(42L), + ListFabricScoped(43L), + TimedWriteBoolean(48L), + GeneralErrorBoolean(49L), + ClusterErrorBoolean(50L), + Unsupported(255L), + NullableBoolean(16384L), + NullableBitmap8(16385L), + NullableBitmap16(16386L), + NullableBitmap32(16387L), + NullableBitmap64(16388L), + NullableInt8u(16389L), + NullableInt16u(16390L), + NullableInt24u(16391L), + NullableInt32u(16392L), + NullableInt40u(16393L), + NullableInt48u(16394L), + NullableInt56u(16395L), + NullableInt64u(16396L), + NullableInt8s(16397L), + NullableInt16s(16398L), + NullableInt24s(16399L), + NullableInt32s(16400L), + NullableInt40s(16401L), + NullableInt48s(16402L), + NullableInt56s(16403L), + NullableInt64s(16404L), + NullableEnum8(16405L), + NullableEnum16(16406L), + NullableFloatSingle(16407L), + NullableFloatDouble(16408L), + NullableOctetString(16409L), + NullableCharString(16414L), + NullableEnumAttr(16420L), + NullableStruct(16421L), + NullableRangeRestrictedInt8u(16422L), + NullableRangeRestrictedInt8s(16423L), + NullableRangeRestrictedInt16u(16424L), + NullableRangeRestrictedInt16s(16425L), + WriteOnlyInt8u(16426L), + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + TestEvent(1L), + TestFabricScopedEvent(2L), + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == TargetNavigator.ID) { - return new TargetNavigator(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + Test(0L), + TestNotHandled(1L), + TestSpecific(2L), + TestUnknownCommand(3L), + TestAddArguments(4L), + TestSimpleArgumentRequest(5L), + TestStructArrayArgumentRequest(6L), + TestStructArgumentRequest(7L), + TestNestedStructArgumentRequest(8L), + TestListStructArgumentRequest(9L), + TestListInt8UArgumentRequest(10L), + TestNestedStructListArgumentRequest(11L), + TestListNestedStructListArgumentRequest(12L), + TestListInt8UReverseRequest(13L), + TestEnumsRequest(14L), + TestNullableOptionalRequest(15L), + TestComplexNullableOptionalRequest(16L), + SimpleStructEchoRequest(17L), + TimedInvokeRequest(18L), + TestSimpleOptionalArgumentRequest(19L), + TestEmitTestEventRequest(20L), + TestEmitTestFabricScopedEventRequest(21L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestAddArgumentsCommandField { + Arg1(0), + Arg2(1), + ; + private final int id; + + TestAddArgumentsCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestAddArgumentsCommandField value(int id) throws NoSuchFieldError { + for (TestAddArgumentsCommandField field : TestAddArgumentsCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == MediaPlayback.ID) { - return new MediaPlayback(); + throw new NoSuchFieldError(); + } + } + + public enum TestSimpleArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestSimpleArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestSimpleArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestSimpleArgumentRequestCommandField field : + TestSimpleArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == MediaInput.ID) { - return new MediaInput(); + throw new NoSuchFieldError(); + } + } + + public enum TestStructArrayArgumentRequestCommandField { + Arg1(0), + Arg2(1), + Arg3(2), + Arg4(3), + Arg5(4), + Arg6(5), + ; + private final int id; + + TestStructArrayArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestStructArrayArgumentRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestStructArrayArgumentRequestCommandField field : + TestStructArrayArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestStructArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestStructArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestStructArgumentRequestCommandField field : + TestStructArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == LowPower.ID) { - return new LowPower(); + throw new NoSuchFieldError(); + } + } + + public enum TestNestedStructArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestNestedStructArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestNestedStructArgumentRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestNestedStructArgumentRequestCommandField field : + TestNestedStructArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestListStructArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestListStructArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestListStructArgumentRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestListStructArgumentRequestCommandField field : + TestListStructArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestListInt8UArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestListInt8UArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestListInt8UArgumentRequestCommandField value(int id) throws NoSuchFieldError { + for (TestListInt8UArgumentRequestCommandField field : + TestListInt8UArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == KeypadInput.ID) { - return new KeypadInput(); + throw new NoSuchFieldError(); + } + } + + public enum TestNestedStructListArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestNestedStructListArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestNestedStructListArgumentRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestNestedStructListArgumentRequestCommandField field : + TestNestedStructListArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestListNestedStructListArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestListNestedStructListArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestListNestedStructListArgumentRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestListNestedStructListArgumentRequestCommandField field : + TestListNestedStructListArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestListInt8UReverseRequestCommandField { + Arg1(0), + ; + private final int id; + + TestListInt8UReverseRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestListInt8UReverseRequestCommandField value(int id) throws NoSuchFieldError { + for (TestListInt8UReverseRequestCommandField field : + TestListInt8UReverseRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ContentLauncher.ID) { - return new ContentLauncher(); + throw new NoSuchFieldError(); + } + } + + public enum TestEnumsRequestCommandField { + Arg1(0), + Arg2(1), + ; + private final int id; + + TestEnumsRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestEnumsRequestCommandField value(int id) throws NoSuchFieldError { + for (TestEnumsRequestCommandField field : TestEnumsRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == AudioOutput.ID) { - return new AudioOutput(); + throw new NoSuchFieldError(); + } + } + + public enum TestNullableOptionalRequestCommandField { + Arg1(0), + ; + private final int id; + + TestNullableOptionalRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestNullableOptionalRequestCommandField value(int id) throws NoSuchFieldError { + for (TestNullableOptionalRequestCommandField field : + TestNullableOptionalRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ApplicationLauncher.ID) { - return new ApplicationLauncher(); + throw new NoSuchFieldError(); + } + } + + public enum TestComplexNullableOptionalRequestCommandField { + NullableInt(0), + OptionalInt(1), + NullableOptionalInt(2), + NullableString(3), + OptionalString(4), + NullableOptionalString(5), + NullableStruct(6), + OptionalStruct(7), + NullableOptionalStruct(8), + NullableList(9), + OptionalList(10), + NullableOptionalList(11), + ; + private final int id; + + TestComplexNullableOptionalRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestComplexNullableOptionalRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestComplexNullableOptionalRequestCommandField field : + TestComplexNullableOptionalRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum SimpleStructEchoRequestCommandField { + Arg1(0), + ; + private final int id; + + SimpleStructEchoRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static SimpleStructEchoRequestCommandField value(int id) throws NoSuchFieldError { + for (SimpleStructEchoRequestCommandField field : + SimpleStructEchoRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } } - if (clusterId == ApplicationBasic.ID) { - return new ApplicationBasic(); + throw new NoSuchFieldError(); + } + } + + public enum TestSimpleOptionalArgumentRequestCommandField { + Arg1(0), + ; + private final int id; + + TestSimpleOptionalArgumentRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestSimpleOptionalArgumentRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestSimpleOptionalArgumentRequestCommandField field : + TestSimpleOptionalArgumentRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestEmitTestEventRequestCommandField { + Arg1(0), + Arg2(1), + Arg3(2), + ; + private final int id; + + TestEmitTestEventRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestEmitTestEventRequestCommandField value(int id) throws NoSuchFieldError { + for (TestEmitTestEventRequestCommandField field : + TestEmitTestEventRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum TestEmitTestFabricScopedEventRequestCommandField { + Arg1(0), + ; + private final int id; + + TestEmitTestFabricScopedEventRequestCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static TestEmitTestFabricScopedEventRequestCommandField value(int id) + throws NoSuchFieldError { + for (TestEmitTestFabricScopedEventRequestCommandField field : + TestEmitTestFabricScopedEventRequestCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } + + public static class FaultInjection implements BaseCluster { + public static final long ID = 4294048774L; + + public long getID() { + return ID; + } + + public enum Attribute { + GeneratedCommandList(65528L), + AcceptedCommandList(65529L), + EventList(65530L), + AttributeList(65531L), + FeatureMap(65532L), + ClusterRevision(65533L), + ; + private final long id; + + Attribute(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Attribute value(long id) throws NoSuchFieldError { + for (Attribute attribute : Attribute.values()) { + if (attribute.getID() == id) { + return attribute; + } + } + throw new NoSuchFieldError(); + } + } + + public enum Event { + ; + private final long id; + + Event(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Event value(long id) throws NoSuchFieldError { + for (Event event : Event.values()) { + if (event.getID() == id) { + return event; + } } - if (clusterId == AccountLogin.ID) { - return new AccountLogin(); + throw new NoSuchFieldError(); + } + } + + public enum Command { + FailAtFault(0L), + FailRandomlyAtFault(1L), + ; + private final long id; + + Command(long id) { + this.id = id; + } + + public long getID() { + return id; + } + + public static Command value(long id) throws NoSuchFieldError { + for (Command command : Command.values()) { + if (command.getID() == id) { + return command; + } } - if (clusterId == ElectricalMeasurement.ID) { - return new ElectricalMeasurement(); - } - if (clusterId == UnitTesting.ID) { - return new UnitTesting(); - } - if (clusterId == FaultInjection.ID) { - return new FaultInjection(); - }return null; - } - public static class Identify implements BaseCluster { - public static final long ID = 3L; - public long getID() { - return ID; - } - - public enum Attribute { - IdentifyTime(0L), - IdentifyType(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Identify(0L), - TriggerEffect(64L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum IdentifyCommandField {IdentifyTime(0),; - private final int id; - IdentifyCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static IdentifyCommandField value(int id) throws NoSuchFieldError { - for (IdentifyCommandField field : IdentifyCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TriggerEffectCommandField {EffectIdentifier(0),EffectVariant(1),; - private final int id; - TriggerEffectCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TriggerEffectCommandField value(int id) throws NoSuchFieldError { - for (TriggerEffectCommandField field : TriggerEffectCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Groups implements BaseCluster { - public static final long ID = 4L; - public long getID() { - return ID; - } - - public enum Attribute { - NameSupport(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AddGroup(0L), - ViewGroup(1L), - GetGroupMembership(2L), - RemoveGroup(3L), - RemoveAllGroups(4L), - AddGroupIfIdentifying(5L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum AddGroupCommandField {GroupID(0),GroupName(1),; - private final int id; - AddGroupCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddGroupCommandField value(int id) throws NoSuchFieldError { - for (AddGroupCommandField field : AddGroupCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ViewGroupCommandField {GroupID(0),; - private final int id; - ViewGroupCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ViewGroupCommandField value(int id) throws NoSuchFieldError { - for (ViewGroupCommandField field : ViewGroupCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetGroupMembershipCommandField {GroupList(0),; - private final int id; - GetGroupMembershipCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetGroupMembershipCommandField value(int id) throws NoSuchFieldError { - for (GetGroupMembershipCommandField field : GetGroupMembershipCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RemoveGroupCommandField {GroupID(0),; - private final int id; - RemoveGroupCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RemoveGroupCommandField value(int id) throws NoSuchFieldError { - for (RemoveGroupCommandField field : RemoveGroupCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum AddGroupIfIdentifyingCommandField {GroupID(0),GroupName(1),; - private final int id; - AddGroupIfIdentifyingCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddGroupIfIdentifyingCommandField value(int id) throws NoSuchFieldError { - for (AddGroupIfIdentifyingCommandField field : AddGroupIfIdentifyingCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Scenes implements BaseCluster { - public static final long ID = 5L; - public long getID() { - return ID; - } - - public enum Attribute { - SceneCount(0L), - CurrentScene(1L), - CurrentGroup(2L), - SceneValid(3L), - NameSupport(4L), - LastConfiguredBy(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AddScene(0L), - ViewScene(1L), - RemoveScene(2L), - RemoveAllScenes(3L), - StoreScene(4L), - RecallScene(5L), - GetSceneMembership(6L), - EnhancedAddScene(64L), - EnhancedViewScene(65L), - CopyScene(66L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum AddSceneCommandField {GroupID(0),SceneID(1),TransitionTime(2),SceneName(3),ExtensionFieldSets(4),; - private final int id; - AddSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddSceneCommandField value(int id) throws NoSuchFieldError { - for (AddSceneCommandField field : AddSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ViewSceneCommandField {GroupID(0),SceneID(1),; - private final int id; - ViewSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ViewSceneCommandField value(int id) throws NoSuchFieldError { - for (ViewSceneCommandField field : ViewSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RemoveSceneCommandField {GroupID(0),SceneID(1),; - private final int id; - RemoveSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RemoveSceneCommandField value(int id) throws NoSuchFieldError { - for (RemoveSceneCommandField field : RemoveSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RemoveAllScenesCommandField {GroupID(0),; - private final int id; - RemoveAllScenesCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RemoveAllScenesCommandField value(int id) throws NoSuchFieldError { - for (RemoveAllScenesCommandField field : RemoveAllScenesCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StoreSceneCommandField {GroupID(0),SceneID(1),; - private final int id; - StoreSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StoreSceneCommandField value(int id) throws NoSuchFieldError { - for (StoreSceneCommandField field : StoreSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RecallSceneCommandField {GroupID(0),SceneID(1),TransitionTime(2),; - private final int id; - RecallSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RecallSceneCommandField value(int id) throws NoSuchFieldError { - for (RecallSceneCommandField field : RecallSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetSceneMembershipCommandField {GroupID(0),; - private final int id; - GetSceneMembershipCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetSceneMembershipCommandField value(int id) throws NoSuchFieldError { - for (GetSceneMembershipCommandField field : GetSceneMembershipCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnhancedAddSceneCommandField {GroupID(0),SceneID(1),TransitionTime(2),SceneName(3),ExtensionFieldSets(4),; - private final int id; - EnhancedAddSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnhancedAddSceneCommandField value(int id) throws NoSuchFieldError { - for (EnhancedAddSceneCommandField field : EnhancedAddSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnhancedViewSceneCommandField {GroupID(0),SceneID(1),; - private final int id; - EnhancedViewSceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnhancedViewSceneCommandField value(int id) throws NoSuchFieldError { - for (EnhancedViewSceneCommandField field : EnhancedViewSceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum CopySceneCommandField {Mode(0),GroupIdentifierFrom(1),SceneIdentifierFrom(2),GroupIdentifierTo(3),SceneIdentifierTo(4),; - private final int id; - CopySceneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static CopySceneCommandField value(int id) throws NoSuchFieldError { - for (CopySceneCommandField field : CopySceneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OnOff implements BaseCluster { - public static final long ID = 6L; - public long getID() { - return ID; - } - - public enum Attribute { - OnOff(0L), - GlobalSceneControl(16384L), - OnTime(16385L), - OffWaitTime(16386L), - StartUpOnOff(16387L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Off(0L), - On(1L), - Toggle(2L), - OffWithEffect(64L), - OnWithRecallGlobalScene(65L), - OnWithTimedOff(66L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum OffWithEffectCommandField {EffectIdentifier(0),EffectVariant(1),; - private final int id; - OffWithEffectCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static OffWithEffectCommandField value(int id) throws NoSuchFieldError { - for (OffWithEffectCommandField field : OffWithEffectCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum OnWithTimedOffCommandField {OnOffControl(0),OnTime(1),OffWaitTime(2),; - private final int id; - OnWithTimedOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static OnWithTimedOffCommandField value(int id) throws NoSuchFieldError { - for (OnWithTimedOffCommandField field : OnWithTimedOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OnOffSwitchConfiguration implements BaseCluster { - public static final long ID = 7L; - public long getID() { - return ID; - } - - public enum Attribute { - SwitchType(0L), - SwitchActions(16L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class LevelControl implements BaseCluster { - public static final long ID = 8L; - public long getID() { - return ID; - } - - public enum Attribute { - CurrentLevel(0L), - RemainingTime(1L), - MinLevel(2L), - MaxLevel(3L), - CurrentFrequency(4L), - MinFrequency(5L), - MaxFrequency(6L), - Options(15L), - OnOffTransitionTime(16L), - OnLevel(17L), - OnTransitionTime(18L), - OffTransitionTime(19L), - DefaultMoveRate(20L), - StartUpCurrentLevel(16384L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - MoveToLevel(0L), - Move(1L), - Step(2L), - Stop(3L), - MoveToLevelWithOnOff(4L), - MoveWithOnOff(5L), - StepWithOnOff(6L), - StopWithOnOff(7L), - MoveToClosestFrequency(8L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToLevelCommandField {Level(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveToLevelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToLevelCommandField value(int id) throws NoSuchFieldError { - for (MoveToLevelCommandField field : MoveToLevelCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveCommandField value(int id) throws NoSuchFieldError { - for (MoveCommandField field : MoveCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StepCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - StepCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StepCommandField value(int id) throws NoSuchFieldError { - for (StepCommandField field : StepCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StopCommandField {OptionsMask(0),OptionsOverride(1),; - private final int id; - StopCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StopCommandField value(int id) throws NoSuchFieldError { - for (StopCommandField field : StopCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToLevelWithOnOffCommandField {Level(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveToLevelWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToLevelWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (MoveToLevelWithOnOffCommandField field : MoveToLevelWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveWithOnOffCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (MoveWithOnOffCommandField field : MoveWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StepWithOnOffCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - StepWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StepWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (StepWithOnOffCommandField field : StepWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StopWithOnOffCommandField {OptionsMask(0),OptionsOverride(1),; - private final int id; - StopWithOnOffCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StopWithOnOffCommandField value(int id) throws NoSuchFieldError { - for (StopWithOnOffCommandField field : StopWithOnOffCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToClosestFrequencyCommandField {Frequency(0),; - private final int id; - MoveToClosestFrequencyCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToClosestFrequencyCommandField value(int id) throws NoSuchFieldError { - for (MoveToClosestFrequencyCommandField field : MoveToClosestFrequencyCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class BinaryInputBasic implements BaseCluster { - public static final long ID = 15L; - public long getID() { - return ID; - } - - public enum Attribute { - ActiveText(4L), - Description(28L), - InactiveText(46L), - OutOfService(81L), - Polarity(84L), - PresentValue(85L), - Reliability(103L), - StatusFlags(111L), - ApplicationType(256L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class PulseWidthModulation implements BaseCluster { - public static final long ID = 28L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Descriptor implements BaseCluster { - public static final long ID = 29L; - public long getID() { - return ID; - } - - public enum Attribute { - DeviceTypeList(0L), - ServerList(1L), - ClientList(2L), - PartsList(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Binding implements BaseCluster { - public static final long ID = 30L; - public long getID() { - return ID; - } - - public enum Attribute { - Binding(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class AccessControl implements BaseCluster { - public static final long ID = 31L; - public long getID() { - return ID; - } - - public enum Attribute { - Acl(0L), - Extension(1L), - SubjectsPerAccessControlEntry(2L), - TargetsPerAccessControlEntry(3L), - AccessControlEntriesPerFabric(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - AccessControlEntryChanged(0L), - AccessControlExtensionChanged(1L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Actions implements BaseCluster { - public static final long ID = 37L; - public long getID() { - return ID; - } - - public enum Attribute { - ActionList(0L), - EndpointLists(1L), - SetupURL(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StateChanged(0L), - ActionFailed(1L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - InstantAction(0L), - InstantActionWithTransition(1L), - StartAction(2L), - StartActionWithDuration(3L), - StopAction(4L), - PauseAction(5L), - PauseActionWithDuration(6L), - ResumeAction(7L), - EnableAction(8L), - EnableActionWithDuration(9L), - DisableAction(10L), - DisableActionWithDuration(11L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum InstantActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - InstantActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static InstantActionCommandField value(int id) throws NoSuchFieldError { - for (InstantActionCommandField field : InstantActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum InstantActionWithTransitionCommandField {ActionID(0),InvokeID(1),TransitionTime(2),; - private final int id; - InstantActionWithTransitionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static InstantActionWithTransitionCommandField value(int id) throws NoSuchFieldError { - for (InstantActionWithTransitionCommandField field : InstantActionWithTransitionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StartActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - StartActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StartActionCommandField value(int id) throws NoSuchFieldError { - for (StartActionCommandField field : StartActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StartActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; - private final int id; - StartActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StartActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (StartActionWithDurationCommandField field : StartActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StopActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - StopActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StopActionCommandField value(int id) throws NoSuchFieldError { - for (StopActionCommandField field : StopActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum PauseActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - PauseActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static PauseActionCommandField value(int id) throws NoSuchFieldError { - for (PauseActionCommandField field : PauseActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum PauseActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; - private final int id; - PauseActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static PauseActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (PauseActionWithDurationCommandField field : PauseActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ResumeActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - ResumeActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ResumeActionCommandField value(int id) throws NoSuchFieldError { - for (ResumeActionCommandField field : ResumeActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnableActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - EnableActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnableActionCommandField value(int id) throws NoSuchFieldError { - for (EnableActionCommandField field : EnableActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnableActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; - private final int id; - EnableActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnableActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (EnableActionWithDurationCommandField field : EnableActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum DisableActionCommandField {ActionID(0),InvokeID(1),; - private final int id; - DisableActionCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static DisableActionCommandField value(int id) throws NoSuchFieldError { - for (DisableActionCommandField field : DisableActionCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum DisableActionWithDurationCommandField {ActionID(0),InvokeID(1),Duration(2),; - private final int id; - DisableActionWithDurationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static DisableActionWithDurationCommandField value(int id) throws NoSuchFieldError { - for (DisableActionWithDurationCommandField field : DisableActionWithDurationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class BasicInformation implements BaseCluster { - public static final long ID = 40L; - public long getID() { - return ID; - } - - public enum Attribute { - DataModelRevision(0L), - VendorName(1L), - VendorID(2L), - ProductName(3L), - ProductID(4L), - NodeLabel(5L), - Location(6L), - HardwareVersion(7L), - HardwareVersionString(8L), - SoftwareVersion(9L), - SoftwareVersionString(10L), - ManufacturingDate(11L), - PartNumber(12L), - ProductURL(13L), - ProductLabel(14L), - SerialNumber(15L), - LocalConfigDisabled(16L), - Reachable(17L), - UniqueID(18L), - CapabilityMinima(19L), - ProductAppearance(20L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StartUp(0L), - ShutDown(1L), - Leave(2L), - ReachableChanged(3L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - MfgSpecificPing(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OtaSoftwareUpdateProvider implements BaseCluster { - public static final long ID = 41L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - QueryImage(0L), - ApplyUpdateRequest(2L), - NotifyUpdateApplied(4L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum QueryImageCommandField {VendorID(0),ProductID(1),SoftwareVersion(2),ProtocolsSupported(3),HardwareVersion(4),Location(5),RequestorCanConsent(6),MetadataForProvider(7),; - private final int id; - QueryImageCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static QueryImageCommandField value(int id) throws NoSuchFieldError { - for (QueryImageCommandField field : QueryImageCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ApplyUpdateRequestCommandField {UpdateToken(0),NewVersion(1),; - private final int id; - ApplyUpdateRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ApplyUpdateRequestCommandField value(int id) throws NoSuchFieldError { - for (ApplyUpdateRequestCommandField field : ApplyUpdateRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum NotifyUpdateAppliedCommandField {UpdateToken(0),SoftwareVersion(1),; - private final int id; - NotifyUpdateAppliedCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static NotifyUpdateAppliedCommandField value(int id) throws NoSuchFieldError { - for (NotifyUpdateAppliedCommandField field : NotifyUpdateAppliedCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OtaSoftwareUpdateRequestor implements BaseCluster { - public static final long ID = 42L; - public long getID() { - return ID; - } - - public enum Attribute { - DefaultOTAProviders(0L), - UpdatePossible(1L), - UpdateState(2L), - UpdateStateProgress(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StateTransition(0L), - VersionApplied(1L), - DownloadError(2L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AnnounceOTAProvider(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum AnnounceOTAProviderCommandField {ProviderNodeID(0),VendorID(1),AnnouncementReason(2),MetadataForNode(3),Endpoint(4),; - private final int id; - AnnounceOTAProviderCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AnnounceOTAProviderCommandField value(int id) throws NoSuchFieldError { - for (AnnounceOTAProviderCommandField field : AnnounceOTAProviderCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class LocalizationConfiguration implements BaseCluster { - public static final long ID = 43L; - public long getID() { - return ID; - } - - public enum Attribute { - ActiveLocale(0L), - SupportedLocales(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class TimeFormatLocalization implements BaseCluster { - public static final long ID = 44L; - public long getID() { - return ID; - } - - public enum Attribute { - HourFormat(0L), - ActiveCalendarType(1L), - SupportedCalendarTypes(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class UnitLocalization implements BaseCluster { - public static final long ID = 45L; - public long getID() { - return ID; - } - - public enum Attribute { - TemperatureUnit(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class PowerSourceConfiguration implements BaseCluster { - public static final long ID = 46L; - public long getID() { - return ID; - } - - public enum Attribute { - Sources(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class PowerSource implements BaseCluster { - public static final long ID = 47L; - public long getID() { - return ID; - } - - public enum Attribute { - Status(0L), - Order(1L), - Description(2L), - WiredAssessedInputVoltage(3L), - WiredAssessedInputFrequency(4L), - WiredCurrentType(5L), - WiredAssessedCurrent(6L), - WiredNominalVoltage(7L), - WiredMaximumCurrent(8L), - WiredPresent(9L), - ActiveWiredFaults(10L), - BatVoltage(11L), - BatPercentRemaining(12L), - BatTimeRemaining(13L), - BatChargeLevel(14L), - BatReplacementNeeded(15L), - BatReplaceability(16L), - BatPresent(17L), - ActiveBatFaults(18L), - BatReplacementDescription(19L), - BatCommonDesignation(20L), - BatANSIDesignation(21L), - BatIECDesignation(22L), - BatApprovedChemistry(23L), - BatCapacity(24L), - BatQuantity(25L), - BatChargeState(26L), - BatTimeToFullCharge(27L), - BatFunctionalWhileCharging(28L), - BatChargingCurrent(29L), - ActiveBatChargeFaults(30L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - WiredFaultChange(0L), - BatFaultChange(1L), - BatChargeFaultChange(2L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class GeneralCommissioning implements BaseCluster { - public static final long ID = 48L; - public long getID() { - return ID; - } - - public enum Attribute { - Breadcrumb(0L), - BasicCommissioningInfo(1L), - RegulatoryConfig(2L), - LocationCapability(3L), - SupportsConcurrentConnection(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ArmFailSafe(0L), - SetRegulatoryConfig(2L), - CommissioningComplete(4L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum ArmFailSafeCommandField {ExpiryLengthSeconds(0),Breadcrumb(1),; - private final int id; - ArmFailSafeCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ArmFailSafeCommandField value(int id) throws NoSuchFieldError { - for (ArmFailSafeCommandField field : ArmFailSafeCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetRegulatoryConfigCommandField {NewRegulatoryConfig(0),CountryCode(1),Breadcrumb(2),; - private final int id; - SetRegulatoryConfigCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetRegulatoryConfigCommandField value(int id) throws NoSuchFieldError { - for (SetRegulatoryConfigCommandField field : SetRegulatoryConfigCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class NetworkCommissioning implements BaseCluster { - public static final long ID = 49L; - public long getID() { - return ID; - } - - public enum Attribute { - MaxNetworks(0L), - Networks(1L), - ScanMaxTimeSeconds(2L), - ConnectMaxTimeSeconds(3L), - InterfaceEnabled(4L), - LastNetworkingStatus(5L), - LastNetworkID(6L), - LastConnectErrorValue(7L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ScanNetworks(0L), - AddOrUpdateWiFiNetwork(2L), - AddOrUpdateThreadNetwork(3L), - RemoveNetwork(4L), - ConnectNetwork(6L), - ReorderNetwork(8L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum ScanNetworksCommandField {Ssid(0),Breadcrumb(1),; - private final int id; - ScanNetworksCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ScanNetworksCommandField value(int id) throws NoSuchFieldError { - for (ScanNetworksCommandField field : ScanNetworksCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum AddOrUpdateWiFiNetworkCommandField {Ssid(0),Credentials(1),Breadcrumb(2),; - private final int id; - AddOrUpdateWiFiNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddOrUpdateWiFiNetworkCommandField value(int id) throws NoSuchFieldError { - for (AddOrUpdateWiFiNetworkCommandField field : AddOrUpdateWiFiNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum AddOrUpdateThreadNetworkCommandField {OperationalDataset(0),Breadcrumb(1),; - private final int id; - AddOrUpdateThreadNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddOrUpdateThreadNetworkCommandField value(int id) throws NoSuchFieldError { - for (AddOrUpdateThreadNetworkCommandField field : AddOrUpdateThreadNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RemoveNetworkCommandField {NetworkID(0),Breadcrumb(1),; - private final int id; - RemoveNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RemoveNetworkCommandField value(int id) throws NoSuchFieldError { - for (RemoveNetworkCommandField field : RemoveNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ConnectNetworkCommandField {NetworkID(0),Breadcrumb(1),; - private final int id; - ConnectNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ConnectNetworkCommandField value(int id) throws NoSuchFieldError { - for (ConnectNetworkCommandField field : ConnectNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ReorderNetworkCommandField {NetworkID(0),NetworkIndex(1),Breadcrumb(2),; - private final int id; - ReorderNetworkCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ReorderNetworkCommandField value(int id) throws NoSuchFieldError { - for (ReorderNetworkCommandField field : ReorderNetworkCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class DiagnosticLogs implements BaseCluster { - public static final long ID = 50L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - RetrieveLogsRequest(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum RetrieveLogsRequestCommandField {Intent(0),RequestedProtocol(1),TransferFileDesignator(2),; - private final int id; - RetrieveLogsRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RetrieveLogsRequestCommandField value(int id) throws NoSuchFieldError { - for (RetrieveLogsRequestCommandField field : RetrieveLogsRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class GeneralDiagnostics implements BaseCluster { - public static final long ID = 51L; - public long getID() { - return ID; - } - - public enum Attribute { - NetworkInterfaces(0L), - RebootCount(1L), - UpTime(2L), - TotalOperationalHours(3L), - BootReason(4L), - ActiveHardwareFaults(5L), - ActiveRadioFaults(6L), - ActiveNetworkFaults(7L), - TestEventTriggersEnabled(8L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - HardwareFaultChange(0L), - RadioFaultChange(1L), - NetworkFaultChange(2L), - BootReason(3L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - TestEventTrigger(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum TestEventTriggerCommandField {EnableKey(0),EventTrigger(1),; - private final int id; - TestEventTriggerCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestEventTriggerCommandField value(int id) throws NoSuchFieldError { - for (TestEventTriggerCommandField field : TestEventTriggerCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class SoftwareDiagnostics implements BaseCluster { - public static final long ID = 52L; - public long getID() { - return ID; - } - - public enum Attribute { - ThreadMetrics(0L), - CurrentHeapFree(1L), - CurrentHeapUsed(2L), - CurrentHeapHighWatermark(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SoftwareFault(0L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetWatermarks(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ThreadNetworkDiagnostics implements BaseCluster { - public static final long ID = 53L; - public long getID() { - return ID; - } - - public enum Attribute { - Channel(0L), - RoutingRole(1L), - NetworkName(2L), - PanId(3L), - ExtendedPanId(4L), - MeshLocalPrefix(5L), - OverrunCount(6L), - NeighborTable(7L), - RouteTable(8L), - PartitionId(9L), - Weighting(10L), - DataVersion(11L), - StableDataVersion(12L), - LeaderRouterId(13L), - DetachedRoleCount(14L), - ChildRoleCount(15L), - RouterRoleCount(16L), - LeaderRoleCount(17L), - AttachAttemptCount(18L), - PartitionIdChangeCount(19L), - BetterPartitionAttachAttemptCount(20L), - ParentChangeCount(21L), - TxTotalCount(22L), - TxUnicastCount(23L), - TxBroadcastCount(24L), - TxAckRequestedCount(25L), - TxAckedCount(26L), - TxNoAckRequestedCount(27L), - TxDataCount(28L), - TxDataPollCount(29L), - TxBeaconCount(30L), - TxBeaconRequestCount(31L), - TxOtherCount(32L), - TxRetryCount(33L), - TxDirectMaxRetryExpiryCount(34L), - TxIndirectMaxRetryExpiryCount(35L), - TxErrCcaCount(36L), - TxErrAbortCount(37L), - TxErrBusyChannelCount(38L), - RxTotalCount(39L), - RxUnicastCount(40L), - RxBroadcastCount(41L), - RxDataCount(42L), - RxDataPollCount(43L), - RxBeaconCount(44L), - RxBeaconRequestCount(45L), - RxOtherCount(46L), - RxAddressFilteredCount(47L), - RxDestAddrFilteredCount(48L), - RxDuplicatedCount(49L), - RxErrNoFrameCount(50L), - RxErrUnknownNeighborCount(51L), - RxErrInvalidSrcAddrCount(52L), - RxErrSecCount(53L), - RxErrFcsCount(54L), - RxErrOtherCount(55L), - ActiveTimestamp(56L), - PendingTimestamp(57L), - Delay(58L), - SecurityPolicy(59L), - ChannelPage0Mask(60L), - OperationalDatasetComponents(61L), - ActiveNetworkFaultsList(62L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - ConnectionStatus(0L), - NetworkFaultChange(1L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCounts(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class WiFiNetworkDiagnostics implements BaseCluster { - public static final long ID = 54L; - public long getID() { - return ID; - } - - public enum Attribute { - Bssid(0L), - SecurityType(1L), - WiFiVersion(2L), - ChannelNumber(3L), - Rssi(4L), - BeaconLostCount(5L), - BeaconRxCount(6L), - PacketMulticastRxCount(7L), - PacketMulticastTxCount(8L), - PacketUnicastRxCount(9L), - PacketUnicastTxCount(10L), - CurrentMaxRate(11L), - OverrunCount(12L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - Disconnection(0L), - AssociationFailure(1L), - ConnectionStatus(2L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCounts(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class EthernetNetworkDiagnostics implements BaseCluster { - public static final long ID = 55L; - public long getID() { - return ID; - } - - public enum Attribute { - PHYRate(0L), - FullDuplex(1L), - PacketRxCount(2L), - PacketTxCount(3L), - TxErrCount(4L), - CollisionCount(5L), - OverrunCount(6L), - CarrierDetect(7L), - TimeSinceReset(8L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCounts(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class TimeSynchronization implements BaseCluster { - public static final long ID = 56L; - public long getID() { - return ID; - } - - public enum Attribute { - UTCTime(0L), - Granularity(1L), - TimeSource(2L), - TrustedTimeSource(3L), - DefaultNTP(4L), - TimeZone(5L), - DSTOffset(6L), - LocalTime(7L), - TimeZoneDatabase(8L), - NTPServerAvailable(9L), - TimeZoneListMaxSize(10L), - DSTOffsetListMaxSize(11L), - SupportsDNSResolve(12L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - DSTTableEmpty(0L), - DSTStatus(1L), - TimeZoneStatus(2L), - TimeFailure(3L), - MissingTrustedTimeSource(4L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SetUTCTime(0L), - SetTrustedTimeSource(1L), - SetTimeZone(2L), - SetDSTOffset(4L), - SetDefaultNTP(5L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SetUTCTimeCommandField {UTCTime(0),Granularity(1),TimeSource(2),; - private final int id; - SetUTCTimeCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetUTCTimeCommandField value(int id) throws NoSuchFieldError { - for (SetUTCTimeCommandField field : SetUTCTimeCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetTrustedTimeSourceCommandField {TrustedTimeSource(0),; - private final int id; - SetTrustedTimeSourceCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetTrustedTimeSourceCommandField value(int id) throws NoSuchFieldError { - for (SetTrustedTimeSourceCommandField field : SetTrustedTimeSourceCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetTimeZoneCommandField {TimeZone(0),; - private final int id; - SetTimeZoneCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetTimeZoneCommandField value(int id) throws NoSuchFieldError { - for (SetTimeZoneCommandField field : SetTimeZoneCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetDSTOffsetCommandField {DSTOffset(0),; - private final int id; - SetDSTOffsetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetDSTOffsetCommandField value(int id) throws NoSuchFieldError { - for (SetDSTOffsetCommandField field : SetDSTOffsetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetDefaultNTPCommandField {DefaultNTP(0),; - private final int id; - SetDefaultNTPCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetDefaultNTPCommandField value(int id) throws NoSuchFieldError { - for (SetDefaultNTPCommandField field : SetDefaultNTPCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class BridgedDeviceBasicInformation implements BaseCluster { - public static final long ID = 57L; - public long getID() { - return ID; - } - - public enum Attribute { - VendorName(1L), - VendorID(2L), - ProductName(3L), - NodeLabel(5L), - HardwareVersion(7L), - HardwareVersionString(8L), - SoftwareVersion(9L), - SoftwareVersionString(10L), - ManufacturingDate(11L), - PartNumber(12L), - ProductURL(13L), - ProductLabel(14L), - SerialNumber(15L), - Reachable(17L), - UniqueID(18L), - ProductAppearance(20L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StartUp(0L), - ShutDown(1L), - Leave(2L), - ReachableChanged(3L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Switch implements BaseCluster { - public static final long ID = 59L; - public long getID() { - return ID; - } - - public enum Attribute { - NumberOfPositions(0L), - CurrentPosition(1L), - MultiPressMax(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SwitchLatched(0L), - InitialPress(1L), - LongPress(2L), - ShortRelease(3L), - LongRelease(4L), - MultiPressOngoing(5L), - MultiPressComplete(6L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class AdministratorCommissioning implements BaseCluster { - public static final long ID = 60L; - public long getID() { - return ID; - } - - public enum Attribute { - WindowStatus(0L), - AdminFabricIndex(1L), - AdminVendorId(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - OpenCommissioningWindow(0L), - OpenBasicCommissioningWindow(1L), - RevokeCommissioning(2L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum OpenCommissioningWindowCommandField {CommissioningTimeout(0),PAKEPasscodeVerifier(1),Discriminator(2),Iterations(3),Salt(4),; - private final int id; - OpenCommissioningWindowCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static OpenCommissioningWindowCommandField value(int id) throws NoSuchFieldError { - for (OpenCommissioningWindowCommandField field : OpenCommissioningWindowCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum OpenBasicCommissioningWindowCommandField {CommissioningTimeout(0),; - private final int id; - OpenBasicCommissioningWindowCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static OpenBasicCommissioningWindowCommandField value(int id) throws NoSuchFieldError { - for (OpenBasicCommissioningWindowCommandField field : OpenBasicCommissioningWindowCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OperationalCredentials implements BaseCluster { - public static final long ID = 62L; - public long getID() { - return ID; - } - - public enum Attribute { - NOCs(0L), - Fabrics(1L), - SupportedFabrics(2L), - CommissionedFabrics(3L), - TrustedRootCertificates(4L), - CurrentFabricIndex(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - AttestationRequest(0L), - CertificateChainRequest(2L), - CSRRequest(4L), - AddNOC(6L), - UpdateNOC(7L), - UpdateFabricLabel(9L), - RemoveFabric(10L), - AddTrustedRootCertificate(11L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum AttestationRequestCommandField {AttestationNonce(0),; - private final int id; - AttestationRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AttestationRequestCommandField value(int id) throws NoSuchFieldError { - for (AttestationRequestCommandField field : AttestationRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum CertificateChainRequestCommandField {CertificateType(0),; - private final int id; - CertificateChainRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static CertificateChainRequestCommandField value(int id) throws NoSuchFieldError { - for (CertificateChainRequestCommandField field : CertificateChainRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum CSRRequestCommandField {CSRNonce(0),IsForUpdateNOC(1),; - private final int id; - CSRRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static CSRRequestCommandField value(int id) throws NoSuchFieldError { - for (CSRRequestCommandField field : CSRRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum AddNOCCommandField {NOCValue(0),ICACValue(1),IPKValue(2),CaseAdminSubject(3),AdminVendorId(4),; - private final int id; - AddNOCCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddNOCCommandField value(int id) throws NoSuchFieldError { - for (AddNOCCommandField field : AddNOCCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum UpdateNOCCommandField {NOCValue(0),ICACValue(1),; - private final int id; - UpdateNOCCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static UpdateNOCCommandField value(int id) throws NoSuchFieldError { - for (UpdateNOCCommandField field : UpdateNOCCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum UpdateFabricLabelCommandField {Label(0),; - private final int id; - UpdateFabricLabelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static UpdateFabricLabelCommandField value(int id) throws NoSuchFieldError { - for (UpdateFabricLabelCommandField field : UpdateFabricLabelCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RemoveFabricCommandField {FabricIndex(0),; - private final int id; - RemoveFabricCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RemoveFabricCommandField value(int id) throws NoSuchFieldError { - for (RemoveFabricCommandField field : RemoveFabricCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum AddTrustedRootCertificateCommandField {RootCACertificate(0),; - private final int id; - AddTrustedRootCertificateCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static AddTrustedRootCertificateCommandField value(int id) throws NoSuchFieldError { - for (AddTrustedRootCertificateCommandField field : AddTrustedRootCertificateCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class GroupKeyManagement implements BaseCluster { - public static final long ID = 63L; - public long getID() { - return ID; - } - - public enum Attribute { - GroupKeyMap(0L), - GroupTable(1L), - MaxGroupsPerFabric(2L), - MaxGroupKeysPerFabric(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - KeySetWrite(0L), - KeySetRead(1L), - KeySetRemove(3L), - KeySetReadAllIndices(4L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum KeySetWriteCommandField {GroupKeySet(0),; - private final int id; - KeySetWriteCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static KeySetWriteCommandField value(int id) throws NoSuchFieldError { - for (KeySetWriteCommandField field : KeySetWriteCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum KeySetReadCommandField {GroupKeySetID(0),; - private final int id; - KeySetReadCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static KeySetReadCommandField value(int id) throws NoSuchFieldError { - for (KeySetReadCommandField field : KeySetReadCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum KeySetRemoveCommandField {GroupKeySetID(0),; - private final int id; - KeySetRemoveCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static KeySetRemoveCommandField value(int id) throws NoSuchFieldError { - for (KeySetRemoveCommandField field : KeySetRemoveCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum KeySetReadAllIndicesCommandField {GroupKeySetIDs(0),; - private final int id; - KeySetReadAllIndicesCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static KeySetReadAllIndicesCommandField value(int id) throws NoSuchFieldError { - for (KeySetReadAllIndicesCommandField field : KeySetReadAllIndicesCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class FixedLabel implements BaseCluster { - public static final long ID = 64L; - public long getID() { - return ID; - } - - public enum Attribute { - LabelList(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class UserLabel implements BaseCluster { - public static final long ID = 65L; - public long getID() { - return ID; - } - - public enum Attribute { - LabelList(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ProxyConfiguration implements BaseCluster { - public static final long ID = 66L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ProxyDiscovery implements BaseCluster { - public static final long ID = 67L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ProxyValid implements BaseCluster { - public static final long ID = 68L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class BooleanState implements BaseCluster { - public static final long ID = 69L; - public long getID() { - return ID; - } - - public enum Attribute { - StateValue(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - StateChange(0L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class IcdManagement implements BaseCluster { - public static final long ID = 70L; - public long getID() { - return ID; - } - - public enum Attribute { - IdleModeInterval(0L), - ActiveModeInterval(1L), - ActiveModeThreshold(2L), - RegisteredClients(3L), - ICDCounter(4L), - ClientsSupportedPerFabric(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - RegisterClient(0L), - UnregisterClient(2L), - StayActiveRequest(3L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum RegisterClientCommandField {CheckInNodeID(0),MonitoredSubject(1),Key(2),VerificationKey(3),; - private final int id; - RegisterClientCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RegisterClientCommandField value(int id) throws NoSuchFieldError { - for (RegisterClientCommandField field : RegisterClientCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum UnregisterClientCommandField {CheckInNodeID(0),Key(1),; - private final int id; - UnregisterClientCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static UnregisterClientCommandField value(int id) throws NoSuchFieldError { - for (UnregisterClientCommandField field : UnregisterClientCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ModeSelect implements BaseCluster { - public static final long ID = 80L; - public long getID() { - return ID; - } - - public enum Attribute { - Description(0L), - StandardNamespace(1L), - SupportedModes(2L), - CurrentMode(3L), - StartUpMode(4L), - OnMode(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ChangeToMode(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum ChangeToModeCommandField {NewMode(0),; - private final int id; - ChangeToModeCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ChangeToModeCommandField value(int id) throws NoSuchFieldError { - for (ChangeToModeCommandField field : ChangeToModeCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class TemperatureControl implements BaseCluster { - public static final long ID = 86L; - public long getID() { - return ID; - } - - public enum Attribute { - TemperatureSetpoint(0L), - MinTemperature(1L), - MaxTemperature(2L), - Step(3L), - CurrentTemperatureLevelIndex(4L), - SupportedTemperatureLevels(5L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SetTemperature(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SetTemperatureCommandField {TargetTemperature(0),TargetTemperatureLevel(1),; - private final int id; - SetTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetTemperatureCommandField value(int id) throws NoSuchFieldError { - for (SetTemperatureCommandField field : SetTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class RefrigeratorAlarm implements BaseCluster { - public static final long ID = 87L; - public long getID() { - return ID; - } - - public enum Attribute { - Mask(0L), - Latch(1L), - State(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - Notify(0L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Reset(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum ResetCommandField {Alarms(0),Mask(1),; - private final int id; - ResetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ResetCommandField value(int id) throws NoSuchFieldError { - for (ResetCommandField field : ResetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class AirQuality implements BaseCluster { - public static final long ID = 91L; - public long getID() { - return ID; - } - - public enum Attribute { - AirQuality(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class SmokeCoAlarm implements BaseCluster { - public static final long ID = 92L; - public long getID() { - return ID; - } - - public enum Attribute { - ExpressedState(0L), - SmokeState(1L), - COState(2L), - BatteryAlert(3L), - DeviceMuted(4L), - TestInProgress(5L), - HardwareFaultAlert(6L), - EndOfServiceAlert(7L), - InterconnectSmokeAlarm(8L), - InterconnectCOAlarm(9L), - ContaminationState(10L), - SensitivityLevel(11L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SmokeAlarm(0L), - COAlarm(1L), - LowBattery(2L), - HardwareFault(3L), - EndOfService(4L), - SelfTestComplete(5L), - AlarmMuted(6L), - MuteEnded(7L), - InterconnectSmokeAlarm(8L), - InterconnectCOAlarm(9L), - AllClear(10L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SelfTestRequest(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class DishwasherAlarm implements BaseCluster { - public static final long ID = 93L; - public long getID() { - return ID; - } - - public enum Attribute { - Mask(0L), - Latch(1L), - State(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - Notify(0L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Reset(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum ResetCommandField {Alarms(0),Mask(1),; - private final int id; - ResetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ResetCommandField value(int id) throws NoSuchFieldError { - for (ResetCommandField field : ResetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class HepaFilterMonitoring implements BaseCluster { - public static final long ID = 113L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ActivatedCarbonFilterMonitoring implements BaseCluster { - public static final long ID = 114L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class CeramicFilterMonitoring implements BaseCluster { - public static final long ID = 115L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ElectrostaticFilterMonitoring implements BaseCluster { - public static final long ID = 116L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class UvFilterMonitoring implements BaseCluster { - public static final long ID = 117L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class IonizingFilterMonitoring implements BaseCluster { - public static final long ID = 118L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ZeoliteFilterMonitoring implements BaseCluster { - public static final long ID = 119L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OzoneFilterMonitoring implements BaseCluster { - public static final long ID = 120L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class WaterTankMonitoring implements BaseCluster { - public static final long ID = 121L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class FuelTankMonitoring implements BaseCluster { - public static final long ID = 122L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class InkCartridgeMonitoring implements BaseCluster { - public static final long ID = 123L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class TonerCartridgeMonitoring implements BaseCluster { - public static final long ID = 124L; - public long getID() { - return ID; - } - - public enum Attribute { - Condition(0L), - DegradationDirection(1L), - ChangeIndication(2L), - InPlaceIndicator(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ResetCondition(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class DoorLock implements BaseCluster { - public static final long ID = 257L; - public long getID() { - return ID; - } - - public enum Attribute { - LockState(0L), - LockType(1L), - ActuatorEnabled(2L), - DoorState(3L), - DoorOpenEvents(4L), - DoorClosedEvents(5L), - OpenPeriod(6L), - NumberOfTotalUsersSupported(17L), - NumberOfPINUsersSupported(18L), - NumberOfRFIDUsersSupported(19L), - NumberOfWeekDaySchedulesSupportedPerUser(20L), - NumberOfYearDaySchedulesSupportedPerUser(21L), - NumberOfHolidaySchedulesSupported(22L), - MaxPINCodeLength(23L), - MinPINCodeLength(24L), - MaxRFIDCodeLength(25L), - MinRFIDCodeLength(26L), - CredentialRulesSupport(27L), - NumberOfCredentialsSupportedPerUser(28L), - Language(33L), - LEDSettings(34L), - AutoRelockTime(35L), - SoundVolume(36L), - OperatingMode(37L), - SupportedOperatingModes(38L), - DefaultConfigurationRegister(39L), - EnableLocalProgramming(40L), - EnableOneTouchLocking(41L), - EnableInsideStatusLED(42L), - EnablePrivacyModeButton(43L), - LocalProgrammingFeatures(44L), - WrongCodeEntryLimit(48L), - UserCodeTemporaryDisableTime(49L), - SendPINOverTheAir(50L), - RequirePINforRemoteOperation(51L), - ExpiringUserTimeout(53L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - DoorLockAlarm(0L), - DoorStateChange(1L), - LockOperation(2L), - LockOperationError(3L), - LockUserChange(4L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - LockDoor(0L), - UnlockDoor(1L), - UnlockWithTimeout(3L), - SetWeekDaySchedule(11L), - GetWeekDaySchedule(12L), - ClearWeekDaySchedule(13L), - SetYearDaySchedule(14L), - GetYearDaySchedule(15L), - ClearYearDaySchedule(16L), - SetHolidaySchedule(17L), - GetHolidaySchedule(18L), - ClearHolidaySchedule(19L), - SetUser(26L), - GetUser(27L), - ClearUser(29L), - SetCredential(34L), - GetCredentialStatus(36L), - ClearCredential(38L), - UnboltDoor(39L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum LockDoorCommandField {PINCode(0),; - private final int id; - LockDoorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static LockDoorCommandField value(int id) throws NoSuchFieldError { - for (LockDoorCommandField field : LockDoorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum UnlockDoorCommandField {PINCode(0),; - private final int id; - UnlockDoorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static UnlockDoorCommandField value(int id) throws NoSuchFieldError { - for (UnlockDoorCommandField field : UnlockDoorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum UnlockWithTimeoutCommandField {Timeout(0),PINCode(1),; - private final int id; - UnlockWithTimeoutCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static UnlockWithTimeoutCommandField value(int id) throws NoSuchFieldError { - for (UnlockWithTimeoutCommandField field : UnlockWithTimeoutCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetWeekDayScheduleCommandField {WeekDayIndex(0),UserIndex(1),DaysMask(2),StartHour(3),StartMinute(4),EndHour(5),EndMinute(6),; - private final int id; - SetWeekDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetWeekDayScheduleCommandField field : SetWeekDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetWeekDayScheduleCommandField {WeekDayIndex(0),UserIndex(1),; - private final int id; - GetWeekDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetWeekDayScheduleCommandField field : GetWeekDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ClearWeekDayScheduleCommandField {WeekDayIndex(0),UserIndex(1),; - private final int id; - ClearWeekDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ClearWeekDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (ClearWeekDayScheduleCommandField field : ClearWeekDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetYearDayScheduleCommandField {YearDayIndex(0),UserIndex(1),LocalStartTime(2),LocalEndTime(3),; - private final int id; - SetYearDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetYearDayScheduleCommandField field : SetYearDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetYearDayScheduleCommandField {YearDayIndex(0),UserIndex(1),; - private final int id; - GetYearDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetYearDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetYearDayScheduleCommandField field : GetYearDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ClearYearDayScheduleCommandField {YearDayIndex(0),UserIndex(1),; - private final int id; - ClearYearDayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ClearYearDayScheduleCommandField value(int id) throws NoSuchFieldError { - for (ClearYearDayScheduleCommandField field : ClearYearDayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetHolidayScheduleCommandField {HolidayIndex(0),LocalStartTime(1),LocalEndTime(2),OperatingMode(3),; - private final int id; - SetHolidayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetHolidayScheduleCommandField field : SetHolidayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetHolidayScheduleCommandField {HolidayIndex(0),; - private final int id; - GetHolidayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetHolidayScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetHolidayScheduleCommandField field : GetHolidayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ClearHolidayScheduleCommandField {HolidayIndex(0),; - private final int id; - ClearHolidayScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ClearHolidayScheduleCommandField value(int id) throws NoSuchFieldError { - for (ClearHolidayScheduleCommandField field : ClearHolidayScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetUserCommandField {OperationType(0),UserIndex(1),UserName(2),UserUniqueID(3),UserStatus(4),UserType(5),CredentialRule(6),; - private final int id; - SetUserCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetUserCommandField value(int id) throws NoSuchFieldError { - for (SetUserCommandField field : SetUserCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetUserCommandField {UserIndex(0),; - private final int id; - GetUserCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetUserCommandField value(int id) throws NoSuchFieldError { - for (GetUserCommandField field : GetUserCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ClearUserCommandField {UserIndex(0),; - private final int id; - ClearUserCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ClearUserCommandField value(int id) throws NoSuchFieldError { - for (ClearUserCommandField field : ClearUserCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetCredentialCommandField {OperationType(0),Credential(1),CredentialData(2),UserIndex(3),UserStatus(4),UserType(5),; - private final int id; - SetCredentialCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetCredentialCommandField value(int id) throws NoSuchFieldError { - for (SetCredentialCommandField field : SetCredentialCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetCredentialStatusCommandField {Credential(0),; - private final int id; - GetCredentialStatusCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetCredentialStatusCommandField value(int id) throws NoSuchFieldError { - for (GetCredentialStatusCommandField field : GetCredentialStatusCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ClearCredentialCommandField {Credential(0),; - private final int id; - ClearCredentialCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ClearCredentialCommandField value(int id) throws NoSuchFieldError { - for (ClearCredentialCommandField field : ClearCredentialCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum UnboltDoorCommandField {PINCode(0),; - private final int id; - UnboltDoorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static UnboltDoorCommandField value(int id) throws NoSuchFieldError { - for (UnboltDoorCommandField field : UnboltDoorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class WindowCovering implements BaseCluster { - public static final long ID = 258L; - public long getID() { - return ID; - } - - public enum Attribute { - Type(0L), - PhysicalClosedLimitLift(1L), - PhysicalClosedLimitTilt(2L), - CurrentPositionLift(3L), - CurrentPositionTilt(4L), - NumberOfActuationsLift(5L), - NumberOfActuationsTilt(6L), - ConfigStatus(7L), - CurrentPositionLiftPercentage(8L), - CurrentPositionTiltPercentage(9L), - OperationalStatus(10L), - TargetPositionLiftPercent100ths(11L), - TargetPositionTiltPercent100ths(12L), - EndProductType(13L), - CurrentPositionLiftPercent100ths(14L), - CurrentPositionTiltPercent100ths(15L), - InstalledOpenLimitLift(16L), - InstalledClosedLimitLift(17L), - InstalledOpenLimitTilt(18L), - InstalledClosedLimitTilt(19L), - Mode(23L), - SafetyStatus(26L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - UpOrOpen(0L), - DownOrClose(1L), - StopMotion(2L), - GoToLiftValue(4L), - GoToLiftPercentage(5L), - GoToTiltValue(7L), - GoToTiltPercentage(8L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum GoToLiftValueCommandField {LiftValue(0),; - private final int id; - GoToLiftValueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GoToLiftValueCommandField value(int id) throws NoSuchFieldError { - for (GoToLiftValueCommandField field : GoToLiftValueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GoToLiftPercentageCommandField {LiftPercent100thsValue(0),; - private final int id; - GoToLiftPercentageCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GoToLiftPercentageCommandField value(int id) throws NoSuchFieldError { - for (GoToLiftPercentageCommandField field : GoToLiftPercentageCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GoToTiltValueCommandField {TiltValue(0),; - private final int id; - GoToTiltValueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GoToTiltValueCommandField value(int id) throws NoSuchFieldError { - for (GoToTiltValueCommandField field : GoToTiltValueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GoToTiltPercentageCommandField {TiltPercent100thsValue(0),; - private final int id; - GoToTiltPercentageCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GoToTiltPercentageCommandField value(int id) throws NoSuchFieldError { - for (GoToTiltPercentageCommandField field : GoToTiltPercentageCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class BarrierControl implements BaseCluster { - public static final long ID = 259L; - public long getID() { - return ID; - } - - public enum Attribute { - BarrierMovingState(1L), - BarrierSafetyStatus(2L), - BarrierCapabilities(3L), - BarrierOpenEvents(4L), - BarrierCloseEvents(5L), - BarrierCommandOpenEvents(6L), - BarrierCommandCloseEvents(7L), - BarrierOpenPeriod(8L), - BarrierClosePeriod(9L), - BarrierPosition(10L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - BarrierControlGoToPercent(0L), - BarrierControlStop(1L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum BarrierControlGoToPercentCommandField {PercentOpen(0),; - private final int id; - BarrierControlGoToPercentCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static BarrierControlGoToPercentCommandField value(int id) throws NoSuchFieldError { - for (BarrierControlGoToPercentCommandField field : BarrierControlGoToPercentCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class PumpConfigurationAndControl implements BaseCluster { - public static final long ID = 512L; - public long getID() { - return ID; - } - - public enum Attribute { - MaxPressure(0L), - MaxSpeed(1L), - MaxFlow(2L), - MinConstPressure(3L), - MaxConstPressure(4L), - MinCompPressure(5L), - MaxCompPressure(6L), - MinConstSpeed(7L), - MaxConstSpeed(8L), - MinConstFlow(9L), - MaxConstFlow(10L), - MinConstTemp(11L), - MaxConstTemp(12L), - PumpStatus(16L), - EffectiveOperationMode(17L), - EffectiveControlMode(18L), - Capacity(19L), - Speed(20L), - LifetimeRunningHours(21L), - Power(22L), - LifetimeEnergyConsumed(23L), - OperationMode(32L), - ControlMode(33L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - SupplyVoltageLow(0L), - SupplyVoltageHigh(1L), - PowerMissingPhase(2L), - SystemPressureLow(3L), - SystemPressureHigh(4L), - DryRunning(5L), - MotorTemperatureHigh(6L), - PumpMotorFatalFailure(7L), - ElectronicTemperatureHigh(8L), - PumpBlocked(9L), - SensorFailure(10L), - ElectronicNonFatalFailure(11L), - ElectronicFatalFailure(12L), - GeneralFault(13L), - Leakage(14L), - AirDetection(15L), - TurbineOperation(16L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Thermostat implements BaseCluster { - public static final long ID = 513L; - public long getID() { - return ID; - } - - public enum Attribute { - LocalTemperature(0L), - OutdoorTemperature(1L), - Occupancy(2L), - AbsMinHeatSetpointLimit(3L), - AbsMaxHeatSetpointLimit(4L), - AbsMinCoolSetpointLimit(5L), - AbsMaxCoolSetpointLimit(6L), - PICoolingDemand(7L), - PIHeatingDemand(8L), - HVACSystemTypeConfiguration(9L), - LocalTemperatureCalibration(16L), - OccupiedCoolingSetpoint(17L), - OccupiedHeatingSetpoint(18L), - UnoccupiedCoolingSetpoint(19L), - UnoccupiedHeatingSetpoint(20L), - MinHeatSetpointLimit(21L), - MaxHeatSetpointLimit(22L), - MinCoolSetpointLimit(23L), - MaxCoolSetpointLimit(24L), - MinSetpointDeadBand(25L), - RemoteSensing(26L), - ControlSequenceOfOperation(27L), - SystemMode(28L), - ThermostatRunningMode(30L), - StartOfWeek(32L), - NumberOfWeeklyTransitions(33L), - NumberOfDailyTransitions(34L), - TemperatureSetpointHold(35L), - TemperatureSetpointHoldDuration(36L), - ThermostatProgrammingOperationMode(37L), - ThermostatRunningState(41L), - SetpointChangeSource(48L), - SetpointChangeAmount(49L), - SetpointChangeSourceTimestamp(50L), - OccupiedSetback(52L), - OccupiedSetbackMin(53L), - OccupiedSetbackMax(54L), - UnoccupiedSetback(55L), - UnoccupiedSetbackMin(56L), - UnoccupiedSetbackMax(57L), - EmergencyHeatDelta(58L), - ACType(64L), - ACCapacity(65L), - ACRefrigerantType(66L), - ACCompressorType(67L), - ACErrorCode(68L), - ACLouverPosition(69L), - ACCoilTemperature(70L), - ACCapacityformat(71L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SetpointRaiseLower(0L), - SetWeeklySchedule(1L), - GetWeeklySchedule(2L), - ClearWeeklySchedule(3L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SetpointRaiseLowerCommandField {Mode(0),Amount(1),; - private final int id; - SetpointRaiseLowerCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetpointRaiseLowerCommandField value(int id) throws NoSuchFieldError { - for (SetpointRaiseLowerCommandField field : SetpointRaiseLowerCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SetWeeklyScheduleCommandField {NumberOfTransitionsForSequence(0),DayOfWeekForSequence(1),ModeForSequence(2),Transitions(3),; - private final int id; - SetWeeklyScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { - for (SetWeeklyScheduleCommandField field : SetWeeklyScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum GetWeeklyScheduleCommandField {DaysToReturn(0),ModeToReturn(1),; - private final int id; - GetWeeklyScheduleCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetWeeklyScheduleCommandField value(int id) throws NoSuchFieldError { - for (GetWeeklyScheduleCommandField field : GetWeeklyScheduleCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class FanControl implements BaseCluster { - public static final long ID = 514L; - public long getID() { - return ID; - } - - public enum Attribute { - FanMode(0L), - FanModeSequence(1L), - PercentSetting(2L), - PercentCurrent(3L), - SpeedMax(4L), - SpeedSetting(5L), - SpeedCurrent(6L), - RockSupport(7L), - RockSetting(8L), - WindSupport(9L), - WindSetting(10L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ThermostatUserInterfaceConfiguration implements BaseCluster { - public static final long ID = 516L; - public long getID() { - return ID; - } - - public enum Attribute { - TemperatureDisplayMode(0L), - KeypadLockout(1L), - ScheduleProgrammingVisibility(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ColorControl implements BaseCluster { - public static final long ID = 768L; - public long getID() { - return ID; - } - - public enum Attribute { - CurrentHue(0L), - CurrentSaturation(1L), - RemainingTime(2L), - CurrentX(3L), - CurrentY(4L), - DriftCompensation(5L), - CompensationText(6L), - ColorTemperatureMireds(7L), - ColorMode(8L), - Options(15L), - NumberOfPrimaries(16L), - Primary1X(17L), - Primary1Y(18L), - Primary1Intensity(19L), - Primary2X(21L), - Primary2Y(22L), - Primary2Intensity(23L), - Primary3X(25L), - Primary3Y(26L), - Primary3Intensity(27L), - Primary4X(32L), - Primary4Y(33L), - Primary4Intensity(34L), - Primary5X(36L), - Primary5Y(37L), - Primary5Intensity(38L), - Primary6X(40L), - Primary6Y(41L), - Primary6Intensity(42L), - WhitePointX(48L), - WhitePointY(49L), - ColorPointRX(50L), - ColorPointRY(51L), - ColorPointRIntensity(52L), - ColorPointGX(54L), - ColorPointGY(55L), - ColorPointGIntensity(56L), - ColorPointBX(58L), - ColorPointBY(59L), - ColorPointBIntensity(60L), - EnhancedCurrentHue(16384L), - EnhancedColorMode(16385L), - ColorLoopActive(16386L), - ColorLoopDirection(16387L), - ColorLoopTime(16388L), - ColorLoopStartEnhancedHue(16389L), - ColorLoopStoredEnhancedHue(16390L), - ColorCapabilities(16394L), - ColorTempPhysicalMinMireds(16395L), - ColorTempPhysicalMaxMireds(16396L), - CoupleColorTempToLevelMinMireds(16397L), - StartUpColorTemperatureMireds(16400L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - MoveToHue(0L), - MoveHue(1L), - StepHue(2L), - MoveToSaturation(3L), - MoveSaturation(4L), - StepSaturation(5L), - MoveToHueAndSaturation(6L), - MoveToColor(7L), - MoveColor(8L), - StepColor(9L), - MoveToColorTemperature(10L), - EnhancedMoveToHue(64L), - EnhancedMoveHue(65L), - EnhancedStepHue(66L), - EnhancedMoveToHueAndSaturation(67L), - ColorLoopSet(68L), - StopMoveStep(71L), - MoveColorTemperature(75L), - StepColorTemperature(76L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToHueCommandField {Hue(0),Direction(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - MoveToHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToHueCommandField value(int id) throws NoSuchFieldError { - for (MoveToHueCommandField field : MoveToHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveHueCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveHueCommandField value(int id) throws NoSuchFieldError { - for (MoveHueCommandField field : MoveHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StepHueCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - StepHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StepHueCommandField value(int id) throws NoSuchFieldError { - for (StepHueCommandField field : StepHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToSaturationCommandField {Saturation(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveToSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToSaturationCommandField value(int id) throws NoSuchFieldError { - for (MoveToSaturationCommandField field : MoveToSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveSaturationCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveSaturationCommandField value(int id) throws NoSuchFieldError { - for (MoveSaturationCommandField field : MoveSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StepSaturationCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - StepSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StepSaturationCommandField value(int id) throws NoSuchFieldError { - for (StepSaturationCommandField field : StepSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToHueAndSaturationCommandField {Hue(0),Saturation(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - MoveToHueAndSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToHueAndSaturationCommandField value(int id) throws NoSuchFieldError { - for (MoveToHueAndSaturationCommandField field : MoveToHueAndSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToColorCommandField {ColorX(0),ColorY(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - MoveToColorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToColorCommandField value(int id) throws NoSuchFieldError { - for (MoveToColorCommandField field : MoveToColorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveColorCommandField {RateX(0),RateY(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveColorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveColorCommandField value(int id) throws NoSuchFieldError { - for (MoveColorCommandField field : MoveColorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StepColorCommandField {StepX(0),StepY(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - StepColorCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StepColorCommandField value(int id) throws NoSuchFieldError { - for (StepColorCommandField field : StepColorCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveToColorTemperatureCommandField {ColorTemperatureMireds(0),TransitionTime(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - MoveToColorTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveToColorTemperatureCommandField value(int id) throws NoSuchFieldError { - for (MoveToColorTemperatureCommandField field : MoveToColorTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnhancedMoveToHueCommandField {EnhancedHue(0),Direction(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - EnhancedMoveToHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnhancedMoveToHueCommandField value(int id) throws NoSuchFieldError { - for (EnhancedMoveToHueCommandField field : EnhancedMoveToHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnhancedMoveHueCommandField {MoveMode(0),Rate(1),OptionsMask(2),OptionsOverride(3),; - private final int id; - EnhancedMoveHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnhancedMoveHueCommandField value(int id) throws NoSuchFieldError { - for (EnhancedMoveHueCommandField field : EnhancedMoveHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnhancedStepHueCommandField {StepMode(0),StepSize(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - EnhancedStepHueCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnhancedStepHueCommandField value(int id) throws NoSuchFieldError { - for (EnhancedStepHueCommandField field : EnhancedStepHueCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum EnhancedMoveToHueAndSaturationCommandField {EnhancedHue(0),Saturation(1),TransitionTime(2),OptionsMask(3),OptionsOverride(4),; - private final int id; - EnhancedMoveToHueAndSaturationCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static EnhancedMoveToHueAndSaturationCommandField value(int id) throws NoSuchFieldError { - for (EnhancedMoveToHueAndSaturationCommandField field : EnhancedMoveToHueAndSaturationCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ColorLoopSetCommandField {UpdateFlags(0),Action(1),Direction(2),Time(3),StartHue(4),OptionsMask(5),OptionsOverride(6),; - private final int id; - ColorLoopSetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ColorLoopSetCommandField value(int id) throws NoSuchFieldError { - for (ColorLoopSetCommandField field : ColorLoopSetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StopMoveStepCommandField {OptionsMask(0),OptionsOverride(1),; - private final int id; - StopMoveStepCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StopMoveStepCommandField value(int id) throws NoSuchFieldError { - for (StopMoveStepCommandField field : StopMoveStepCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum MoveColorTemperatureCommandField {MoveMode(0),Rate(1),ColorTemperatureMinimumMireds(2),ColorTemperatureMaximumMireds(3),OptionsMask(4),OptionsOverride(5),; - private final int id; - MoveColorTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static MoveColorTemperatureCommandField value(int id) throws NoSuchFieldError { - for (MoveColorTemperatureCommandField field : MoveColorTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StepColorTemperatureCommandField {StepMode(0),StepSize(1),TransitionTime(2),ColorTemperatureMinimumMireds(3),ColorTemperatureMaximumMireds(4),OptionsMask(5),OptionsOverride(6),; - private final int id; - StepColorTemperatureCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StepColorTemperatureCommandField value(int id) throws NoSuchFieldError { - for (StepColorTemperatureCommandField field : StepColorTemperatureCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class BallastConfiguration implements BaseCluster { - public static final long ID = 769L; - public long getID() { - return ID; - } - - public enum Attribute { - PhysicalMinLevel(0L), - PhysicalMaxLevel(1L), - BallastStatus(2L), - MinLevel(16L), - MaxLevel(17L), - IntrinsicBallastFactor(20L), - BallastFactorAdjustment(21L), - LampQuantity(32L), - LampType(48L), - LampManufacturer(49L), - LampRatedHours(50L), - LampBurnHours(51L), - LampAlarmMode(52L), - LampBurnHoursTripPoint(53L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class IlluminanceMeasurement implements BaseCluster { - public static final long ID = 1024L; - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - LightSensorType(4L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class TemperatureMeasurement implements BaseCluster { - public static final long ID = 1026L; - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class PressureMeasurement implements BaseCluster { - public static final long ID = 1027L; - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - ScaledValue(16L), - MinScaledValue(17L), - MaxScaledValue(18L), - ScaledTolerance(19L), - Scale(20L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class FlowMeasurement implements BaseCluster { - public static final long ID = 1028L; - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class RelativeHumidityMeasurement implements BaseCluster { - public static final long ID = 1029L; - public long getID() { - return ID; - } - - public enum Attribute { - MeasuredValue(0L), - MinMeasuredValue(1L), - MaxMeasuredValue(2L), - Tolerance(3L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class OccupancySensing implements BaseCluster { - public static final long ID = 1030L; - public long getID() { - return ID; - } - - public enum Attribute { - Occupancy(0L), - OccupancySensorType(1L), - OccupancySensorTypeBitmap(2L), - PIROccupiedToUnoccupiedDelay(16L), - PIRUnoccupiedToOccupiedDelay(17L), - PIRUnoccupiedToOccupiedThreshold(18L), - UltrasonicOccupiedToUnoccupiedDelay(32L), - UltrasonicUnoccupiedToOccupiedDelay(33L), - UltrasonicUnoccupiedToOccupiedThreshold(34L), - PhysicalContactOccupiedToUnoccupiedDelay(48L), - PhysicalContactUnoccupiedToOccupiedDelay(49L), - PhysicalContactUnoccupiedToOccupiedThreshold(50L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class WakeOnLan implements BaseCluster { - public static final long ID = 1283L; - public long getID() { - return ID; - } - - public enum Attribute { - MACAddress(0L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class Channel implements BaseCluster { - public static final long ID = 1284L; - public long getID() { - return ID; - } - - public enum Attribute { - ChannelList(0L), - Lineup(1L), - CurrentChannel(2L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - ChangeChannel(0L), - ChangeChannelByNumber(2L), - SkipChannel(3L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum ChangeChannelCommandField {Match(0),; - private final int id; - ChangeChannelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ChangeChannelCommandField value(int id) throws NoSuchFieldError { - for (ChangeChannelCommandField field : ChangeChannelCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum ChangeChannelByNumberCommandField {MajorNumber(0),MinorNumber(1),; - private final int id; - ChangeChannelByNumberCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static ChangeChannelByNumberCommandField value(int id) throws NoSuchFieldError { - for (ChangeChannelByNumberCommandField field : ChangeChannelByNumberCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SkipChannelCommandField {Count(0),; - private final int id; - SkipChannelCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SkipChannelCommandField value(int id) throws NoSuchFieldError { - for (SkipChannelCommandField field : SkipChannelCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class TargetNavigator implements BaseCluster { - public static final long ID = 1285L; - public long getID() { - return ID; - } - - public enum Attribute { - TargetList(0L), - CurrentTarget(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - NavigateTarget(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum NavigateTargetCommandField {Target(0),Data(1),; - private final int id; - NavigateTargetCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static NavigateTargetCommandField value(int id) throws NoSuchFieldError { - for (NavigateTargetCommandField field : NavigateTargetCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class MediaPlayback implements BaseCluster { - public static final long ID = 1286L; - public long getID() { - return ID; - } - - public enum Attribute { - CurrentState(0L), - StartTime(1L), - Duration(2L), - SampledPosition(3L), - PlaybackSpeed(4L), - SeekRangeEnd(5L), - SeekRangeStart(6L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Play(0L), - Pause(1L), - Stop(2L), - StartOver(3L), - Previous(4L), - Next(5L), - Rewind(6L), - FastForward(7L), - SkipForward(8L), - SkipBackward(9L), - Seek(11L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SkipForwardCommandField {DeltaPositionMilliseconds(0),; - private final int id; - SkipForwardCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SkipForwardCommandField value(int id) throws NoSuchFieldError { - for (SkipForwardCommandField field : SkipForwardCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SkipBackwardCommandField {DeltaPositionMilliseconds(0),; - private final int id; - SkipBackwardCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SkipBackwardCommandField value(int id) throws NoSuchFieldError { - for (SkipBackwardCommandField field : SkipBackwardCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SeekCommandField {Position(0),; - private final int id; - SeekCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SeekCommandField value(int id) throws NoSuchFieldError { - for (SeekCommandField field : SeekCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class MediaInput implements BaseCluster { - public static final long ID = 1287L; - public long getID() { - return ID; - } - - public enum Attribute { - InputList(0L), - CurrentInput(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SelectInput(0L), - ShowInputStatus(1L), - HideInputStatus(2L), - RenameInput(3L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SelectInputCommandField {Index(0),; - private final int id; - SelectInputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SelectInputCommandField value(int id) throws NoSuchFieldError { - for (SelectInputCommandField field : SelectInputCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RenameInputCommandField {Index(0),Name(1),; - private final int id; - RenameInputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RenameInputCommandField value(int id) throws NoSuchFieldError { - for (RenameInputCommandField field : RenameInputCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class LowPower implements BaseCluster { - public static final long ID = 1288L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Sleep(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class KeypadInput implements BaseCluster { - public static final long ID = 1289L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SendKey(0L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SendKeyCommandField {KeyCode(0),; - private final int id; - SendKeyCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SendKeyCommandField value(int id) throws NoSuchFieldError { - for (SendKeyCommandField field : SendKeyCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ContentLauncher implements BaseCluster { - public static final long ID = 1290L; - public long getID() { - return ID; - } - - public enum Attribute { - AcceptHeader(0L), - SupportedStreamingProtocols(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - LaunchContent(0L), - LaunchURL(1L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum LaunchContentCommandField {Search(0),AutoPlay(1),Data(2),; - private final int id; - LaunchContentCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static LaunchContentCommandField value(int id) throws NoSuchFieldError { - for (LaunchContentCommandField field : LaunchContentCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum LaunchURLCommandField {ContentURL(0),DisplayString(1),BrandingInformation(2),; - private final int id; - LaunchURLCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static LaunchURLCommandField value(int id) throws NoSuchFieldError { - for (LaunchURLCommandField field : LaunchURLCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class AudioOutput implements BaseCluster { - public static final long ID = 1291L; - public long getID() { - return ID; - } - - public enum Attribute { - OutputList(0L), - CurrentOutput(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - SelectOutput(0L), - RenameOutput(1L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum SelectOutputCommandField {Index(0),; - private final int id; - SelectOutputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SelectOutputCommandField value(int id) throws NoSuchFieldError { - for (SelectOutputCommandField field : SelectOutputCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum RenameOutputCommandField {Index(0),Name(1),; - private final int id; - RenameOutputCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static RenameOutputCommandField value(int id) throws NoSuchFieldError { - for (RenameOutputCommandField field : RenameOutputCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ApplicationLauncher implements BaseCluster { - public static final long ID = 1292L; - public long getID() { - return ID; - } - - public enum Attribute { - CatalogList(0L), - CurrentApp(1L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - LaunchApp(0L), - StopApp(1L), - HideApp(2L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum LaunchAppCommandField {Application(0),Data(1),; - private final int id; - LaunchAppCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static LaunchAppCommandField value(int id) throws NoSuchFieldError { - for (LaunchAppCommandField field : LaunchAppCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum StopAppCommandField {Application(0),; - private final int id; - StopAppCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static StopAppCommandField value(int id) throws NoSuchFieldError { - for (StopAppCommandField field : StopAppCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum HideAppCommandField {Application(0),; - private final int id; - HideAppCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static HideAppCommandField value(int id) throws NoSuchFieldError { - for (HideAppCommandField field : HideAppCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ApplicationBasic implements BaseCluster { - public static final long ID = 1293L; - public long getID() { - return ID; - } - - public enum Attribute { - VendorName(0L), - VendorID(1L), - ApplicationName(2L), - ProductID(3L), - Application(4L), - Status(5L), - ApplicationVersion(6L), - AllowedVendorList(7L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command {; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class AccountLogin implements BaseCluster { - public static final long ID = 1294L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - GetSetupPIN(0L), - Login(2L), - Logout(3L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum GetSetupPINCommandField {TempAccountIdentifier(0),; - private final int id; - GetSetupPINCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetSetupPINCommandField value(int id) throws NoSuchFieldError { - for (GetSetupPINCommandField field : GetSetupPINCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum LoginCommandField {TempAccountIdentifier(0),SetupPIN(1),; - private final int id; - LoginCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static LoginCommandField value(int id) throws NoSuchFieldError { - for (LoginCommandField field : LoginCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class ElectricalMeasurement implements BaseCluster { - public static final long ID = 2820L; - public long getID() { - return ID; - } - - public enum Attribute { - MeasurementType(0L), - DcVoltage(256L), - DcVoltageMin(257L), - DcVoltageMax(258L), - DcCurrent(259L), - DcCurrentMin(260L), - DcCurrentMax(261L), - DcPower(262L), - DcPowerMin(263L), - DcPowerMax(264L), - DcVoltageMultiplier(512L), - DcVoltageDivisor(513L), - DcCurrentMultiplier(514L), - DcCurrentDivisor(515L), - DcPowerMultiplier(516L), - DcPowerDivisor(517L), - AcFrequency(768L), - AcFrequencyMin(769L), - AcFrequencyMax(770L), - NeutralCurrent(771L), - TotalActivePower(772L), - TotalReactivePower(773L), - TotalApparentPower(774L), - Measured1stHarmonicCurrent(775L), - Measured3rdHarmonicCurrent(776L), - Measured5thHarmonicCurrent(777L), - Measured7thHarmonicCurrent(778L), - Measured9thHarmonicCurrent(779L), - Measured11thHarmonicCurrent(780L), - MeasuredPhase1stHarmonicCurrent(781L), - MeasuredPhase3rdHarmonicCurrent(782L), - MeasuredPhase5thHarmonicCurrent(783L), - MeasuredPhase7thHarmonicCurrent(784L), - MeasuredPhase9thHarmonicCurrent(785L), - MeasuredPhase11thHarmonicCurrent(786L), - AcFrequencyMultiplier(1024L), - AcFrequencyDivisor(1025L), - PowerMultiplier(1026L), - PowerDivisor(1027L), - HarmonicCurrentMultiplier(1028L), - PhaseHarmonicCurrentMultiplier(1029L), - InstantaneousVoltage(1280L), - InstantaneousLineCurrent(1281L), - InstantaneousActiveCurrent(1282L), - InstantaneousReactiveCurrent(1283L), - InstantaneousPower(1284L), - RmsVoltage(1285L), - RmsVoltageMin(1286L), - RmsVoltageMax(1287L), - RmsCurrent(1288L), - RmsCurrentMin(1289L), - RmsCurrentMax(1290L), - ActivePower(1291L), - ActivePowerMin(1292L), - ActivePowerMax(1293L), - ReactivePower(1294L), - ApparentPower(1295L), - PowerFactor(1296L), - AverageRmsVoltageMeasurementPeriod(1297L), - AverageRmsUnderVoltageCounter(1299L), - RmsExtremeOverVoltagePeriod(1300L), - RmsExtremeUnderVoltagePeriod(1301L), - RmsVoltageSagPeriod(1302L), - RmsVoltageSwellPeriod(1303L), - AcVoltageMultiplier(1536L), - AcVoltageDivisor(1537L), - AcCurrentMultiplier(1538L), - AcCurrentDivisor(1539L), - AcPowerMultiplier(1540L), - AcPowerDivisor(1541L), - OverloadAlarmsMask(1792L), - VoltageOverload(1793L), - CurrentOverload(1794L), - AcOverloadAlarmsMask(2048L), - AcVoltageOverload(2049L), - AcCurrentOverload(2050L), - AcActivePowerOverload(2051L), - AcReactivePowerOverload(2052L), - AverageRmsOverVoltage(2053L), - AverageRmsUnderVoltage(2054L), - RmsExtremeOverVoltage(2055L), - RmsExtremeUnderVoltage(2056L), - RmsVoltageSag(2057L), - RmsVoltageSwell(2058L), - LineCurrentPhaseB(2305L), - ActiveCurrentPhaseB(2306L), - ReactiveCurrentPhaseB(2307L), - RmsVoltagePhaseB(2309L), - RmsVoltageMinPhaseB(2310L), - RmsVoltageMaxPhaseB(2311L), - RmsCurrentPhaseB(2312L), - RmsCurrentMinPhaseB(2313L), - RmsCurrentMaxPhaseB(2314L), - ActivePowerPhaseB(2315L), - ActivePowerMinPhaseB(2316L), - ActivePowerMaxPhaseB(2317L), - ReactivePowerPhaseB(2318L), - ApparentPowerPhaseB(2319L), - PowerFactorPhaseB(2320L), - AverageRmsVoltageMeasurementPeriodPhaseB(2321L), - AverageRmsOverVoltageCounterPhaseB(2322L), - AverageRmsUnderVoltageCounterPhaseB(2323L), - RmsExtremeOverVoltagePeriodPhaseB(2324L), - RmsExtremeUnderVoltagePeriodPhaseB(2325L), - RmsVoltageSagPeriodPhaseB(2326L), - RmsVoltageSwellPeriodPhaseB(2327L), - LineCurrentPhaseC(2561L), - ActiveCurrentPhaseC(2562L), - ReactiveCurrentPhaseC(2563L), - RmsVoltagePhaseC(2565L), - RmsVoltageMinPhaseC(2566L), - RmsVoltageMaxPhaseC(2567L), - RmsCurrentPhaseC(2568L), - RmsCurrentMinPhaseC(2569L), - RmsCurrentMaxPhaseC(2570L), - ActivePowerPhaseC(2571L), - ActivePowerMinPhaseC(2572L), - ActivePowerMaxPhaseC(2573L), - ReactivePowerPhaseC(2574L), - ApparentPowerPhaseC(2575L), - PowerFactorPhaseC(2576L), - AverageRmsVoltageMeasurementPeriodPhaseC(2577L), - AverageRmsOverVoltageCounterPhaseC(2578L), - AverageRmsUnderVoltageCounterPhaseC(2579L), - RmsExtremeOverVoltagePeriodPhaseC(2580L), - RmsExtremeUnderVoltagePeriodPhaseC(2581L), - RmsVoltageSagPeriodPhaseC(2582L), - RmsVoltageSwellPeriodPhaseC(2583L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - GetProfileInfoCommand(0L), - GetMeasurementProfileCommand(1L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum GetMeasurementProfileCommandCommandField {AttributeId(0),StartTime(1),NumberOfIntervals(2),; - private final int id; - GetMeasurementProfileCommandCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static GetMeasurementProfileCommandCommandField value(int id) throws NoSuchFieldError { - for (GetMeasurementProfileCommandCommandField field : GetMeasurementProfileCommandCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class UnitTesting implements BaseCluster { - public static final long ID = 4294048773L; - public long getID() { - return ID; - } - - public enum Attribute { - Boolean(0L), - Bitmap8(1L), - Bitmap16(2L), - Bitmap32(3L), - Bitmap64(4L), - Int8u(5L), - Int16u(6L), - Int24u(7L), - Int32u(8L), - Int40u(9L), - Int48u(10L), - Int56u(11L), - Int64u(12L), - Int8s(13L), - Int16s(14L), - Int24s(15L), - Int32s(16L), - Int40s(17L), - Int48s(18L), - Int56s(19L), - Int64s(20L), - Enum8(21L), - Enum16(22L), - FloatSingle(23L), - FloatDouble(24L), - OctetString(25L), - ListInt8u(26L), - ListOctetString(27L), - ListStructOctetString(28L), - LongOctetString(29L), - CharString(30L), - LongCharString(31L), - EpochUs(32L), - EpochS(33L), - VendorId(34L), - ListNullablesAndOptionalsStruct(35L), - EnumAttr(36L), - StructAttr(37L), - RangeRestrictedInt8u(38L), - RangeRestrictedInt8s(39L), - RangeRestrictedInt16u(40L), - RangeRestrictedInt16s(41L), - ListLongOctetString(42L), - ListFabricScoped(43L), - TimedWriteBoolean(48L), - GeneralErrorBoolean(49L), - ClusterErrorBoolean(50L), - Unsupported(255L), - NullableBoolean(16384L), - NullableBitmap8(16385L), - NullableBitmap16(16386L), - NullableBitmap32(16387L), - NullableBitmap64(16388L), - NullableInt8u(16389L), - NullableInt16u(16390L), - NullableInt24u(16391L), - NullableInt32u(16392L), - NullableInt40u(16393L), - NullableInt48u(16394L), - NullableInt56u(16395L), - NullableInt64u(16396L), - NullableInt8s(16397L), - NullableInt16s(16398L), - NullableInt24s(16399L), - NullableInt32s(16400L), - NullableInt40s(16401L), - NullableInt48s(16402L), - NullableInt56s(16403L), - NullableInt64s(16404L), - NullableEnum8(16405L), - NullableEnum16(16406L), - NullableFloatSingle(16407L), - NullableFloatDouble(16408L), - NullableOctetString(16409L), - NullableCharString(16414L), - NullableEnumAttr(16420L), - NullableStruct(16421L), - NullableRangeRestrictedInt8u(16422L), - NullableRangeRestrictedInt8s(16423L), - NullableRangeRestrictedInt16u(16424L), - NullableRangeRestrictedInt16s(16425L), - WriteOnlyInt8u(16426L), - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event { - TestEvent(1L), - TestFabricScopedEvent(2L),; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - Test(0L), - TestNotHandled(1L), - TestSpecific(2L), - TestUnknownCommand(3L), - TestAddArguments(4L), - TestSimpleArgumentRequest(5L), - TestStructArrayArgumentRequest(6L), - TestStructArgumentRequest(7L), - TestNestedStructArgumentRequest(8L), - TestListStructArgumentRequest(9L), - TestListInt8UArgumentRequest(10L), - TestNestedStructListArgumentRequest(11L), - TestListNestedStructListArgumentRequest(12L), - TestListInt8UReverseRequest(13L), - TestEnumsRequest(14L), - TestNullableOptionalRequest(15L), - TestComplexNullableOptionalRequest(16L), - SimpleStructEchoRequest(17L), - TimedInvokeRequest(18L), - TestSimpleOptionalArgumentRequest(19L), - TestEmitTestEventRequest(20L), - TestEmitTestFabricScopedEventRequest(21L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum TestAddArgumentsCommandField {Arg1(0),Arg2(1),; - private final int id; - TestAddArgumentsCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestAddArgumentsCommandField value(int id) throws NoSuchFieldError { - for (TestAddArgumentsCommandField field : TestAddArgumentsCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestSimpleArgumentRequestCommandField {Arg1(0),; - private final int id; - TestSimpleArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestSimpleArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestSimpleArgumentRequestCommandField field : TestSimpleArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestStructArrayArgumentRequestCommandField {Arg1(0),Arg2(1),Arg3(2),Arg4(3),Arg5(4),Arg6(5),; - private final int id; - TestStructArrayArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestStructArrayArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestStructArrayArgumentRequestCommandField field : TestStructArrayArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestStructArgumentRequestCommandField {Arg1(0),; - private final int id; - TestStructArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestStructArgumentRequestCommandField field : TestStructArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestNestedStructArgumentRequestCommandField {Arg1(0),; - private final int id; - TestNestedStructArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestNestedStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestNestedStructArgumentRequestCommandField field : TestNestedStructArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestListStructArgumentRequestCommandField {Arg1(0),; - private final int id; - TestListStructArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestListStructArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestListStructArgumentRequestCommandField field : TestListStructArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestListInt8UArgumentRequestCommandField {Arg1(0),; - private final int id; - TestListInt8UArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestListInt8UArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestListInt8UArgumentRequestCommandField field : TestListInt8UArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestNestedStructListArgumentRequestCommandField {Arg1(0),; - private final int id; - TestNestedStructListArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestNestedStructListArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestNestedStructListArgumentRequestCommandField field : TestNestedStructListArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestListNestedStructListArgumentRequestCommandField {Arg1(0),; - private final int id; - TestListNestedStructListArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestListNestedStructListArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestListNestedStructListArgumentRequestCommandField field : TestListNestedStructListArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestListInt8UReverseRequestCommandField {Arg1(0),; - private final int id; - TestListInt8UReverseRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestListInt8UReverseRequestCommandField value(int id) throws NoSuchFieldError { - for (TestListInt8UReverseRequestCommandField field : TestListInt8UReverseRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestEnumsRequestCommandField {Arg1(0),Arg2(1),; - private final int id; - TestEnumsRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestEnumsRequestCommandField value(int id) throws NoSuchFieldError { - for (TestEnumsRequestCommandField field : TestEnumsRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestNullableOptionalRequestCommandField {Arg1(0),; - private final int id; - TestNullableOptionalRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestNullableOptionalRequestCommandField value(int id) throws NoSuchFieldError { - for (TestNullableOptionalRequestCommandField field : TestNullableOptionalRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestComplexNullableOptionalRequestCommandField {NullableInt(0),OptionalInt(1),NullableOptionalInt(2),NullableString(3),OptionalString(4),NullableOptionalString(5),NullableStruct(6),OptionalStruct(7),NullableOptionalStruct(8),NullableList(9),OptionalList(10),NullableOptionalList(11),; - private final int id; - TestComplexNullableOptionalRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestComplexNullableOptionalRequestCommandField value(int id) throws NoSuchFieldError { - for (TestComplexNullableOptionalRequestCommandField field : TestComplexNullableOptionalRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum SimpleStructEchoRequestCommandField {Arg1(0),; - private final int id; - SimpleStructEchoRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static SimpleStructEchoRequestCommandField value(int id) throws NoSuchFieldError { - for (SimpleStructEchoRequestCommandField field : SimpleStructEchoRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestSimpleOptionalArgumentRequestCommandField {Arg1(0),; - private final int id; - TestSimpleOptionalArgumentRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestSimpleOptionalArgumentRequestCommandField value(int id) throws NoSuchFieldError { - for (TestSimpleOptionalArgumentRequestCommandField field : TestSimpleOptionalArgumentRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestEmitTestEventRequestCommandField {Arg1(0),Arg2(1),Arg3(2),; - private final int id; - TestEmitTestEventRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestEmitTestEventRequestCommandField value(int id) throws NoSuchFieldError { - for (TestEmitTestEventRequestCommandField field : TestEmitTestEventRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum TestEmitTestFabricScopedEventRequestCommandField {Arg1(0),; - private final int id; - TestEmitTestFabricScopedEventRequestCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static TestEmitTestFabricScopedEventRequestCommandField value(int id) throws NoSuchFieldError { - for (TestEmitTestFabricScopedEventRequestCommandField field : TestEmitTestFabricScopedEventRequestCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - } - public static class FaultInjection implements BaseCluster { - public static final long ID = 4294048774L; - public long getID() { - return ID; - } - - public enum Attribute { - GeneratedCommandList(65528L), - AcceptedCommandList(65529L), - EventList(65530L), - AttributeList(65531L), - FeatureMap(65532L), - ClusterRevision(65533L),; - private final long id; - Attribute(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Attribute value(long id) throws NoSuchFieldError { - for (Attribute attribute : Attribute.values()) { - if (attribute.getID() == id) { - return attribute; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Event {; - private final long id; - Event(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Event value(long id) throws NoSuchFieldError { - for (Event event : Event.values()) { - if (event.getID() == id) { - return event; - } - } - throw new NoSuchFieldError(); - } - } - - public enum Command { - FailAtFault(0L), - FailRandomlyAtFault(1L),; - private final long id; - Command(long id) { - this.id = id; - } - - public long getID() { - return id; - } - - public static Command value(long id) throws NoSuchFieldError { - for (Command command : Command.values()) { - if (command.getID() == id) { - return command; - } - } - throw new NoSuchFieldError(); - } - }public enum FailAtFaultCommandField {Type(0),Id(1),NumCallsToSkip(2),NumCallsToFail(3),TakeMutex(4),; - private final int id; - FailAtFaultCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static FailAtFaultCommandField value(int id) throws NoSuchFieldError { - for (FailAtFaultCommandField field : FailAtFaultCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }public enum FailRandomlyAtFaultCommandField {Type(0),Id(1),Percentage(2),; - private final int id; - FailRandomlyAtFaultCommandField(int id) { - this.id = id; - } - - public int getID() { - return id; - } - public static FailRandomlyAtFaultCommandField value(int id) throws NoSuchFieldError { - for (FailRandomlyAtFaultCommandField field : FailRandomlyAtFaultCommandField.values()) { - if (field.getID() == id) { - return field; - } - } - throw new NoSuchFieldError(); - } - }@Override - public String getAttributeName(long id) throws NoSuchFieldError { - return Attribute.value(id).toString(); - } - - @Override - public String getEventName(long id) throws NoSuchFieldError { - return Event.value(id).toString(); - } - - @Override - public String getCommandName(long id) throws NoSuchFieldError { - return Command.value(id).toString(); - } - - @Override - public long getAttributeID(String name) throws IllegalArgumentException { - return Attribute.valueOf(name).getID(); - } - - @Override - public long getEventID(String name) throws IllegalArgumentException { - return Event.valueOf(name).getID(); - } - - @Override - public long getCommandID(String name) throws IllegalArgumentException { - return Command.valueOf(name).getID(); - } - }} + throw new NoSuchFieldError(); + } + } + + public enum FailAtFaultCommandField { + Type(0), + Id(1), + NumCallsToSkip(2), + NumCallsToFail(3), + TakeMutex(4), + ; + private final int id; + + FailAtFaultCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static FailAtFaultCommandField value(int id) throws NoSuchFieldError { + for (FailAtFaultCommandField field : FailAtFaultCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + public enum FailRandomlyAtFaultCommandField { + Type(0), + Id(1), + Percentage(2), + ; + private final int id; + + FailRandomlyAtFaultCommandField(int id) { + this.id = id; + } + + public int getID() { + return id; + } + + public static FailRandomlyAtFaultCommandField value(int id) throws NoSuchFieldError { + for (FailRandomlyAtFaultCommandField field : FailRandomlyAtFaultCommandField.values()) { + if (field.getID() == id) { + return field; + } + } + throw new NoSuchFieldError(); + } + } + + @Override + public String getAttributeName(long id) throws NoSuchFieldError { + return Attribute.value(id).toString(); + } + + @Override + public String getEventName(long id) throws NoSuchFieldError { + return Event.value(id).toString(); + } + + @Override + public String getCommandName(long id) throws NoSuchFieldError { + return Command.value(id).toString(); + } + + @Override + public long getAttributeID(String name) throws IllegalArgumentException { + return Attribute.valueOf(name).getID(); + } + + @Override + public long getEventID(String name) throws IllegalArgumentException { + return Event.valueOf(name).getID(); + } + + @Override + public long getCommandID(String name) throws IllegalArgumentException { + return Command.valueOf(name).getID(); + } + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index 5b92382eff1786..66c26f27cc3e69 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -24,15592 +24,19989 @@ public class ClusterReadMapping { + private static Map readIdentifyInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams); + result.put("readIdentifyTimeAttribute", readIdentifyIdentifyTimeAttributeInteractionInfo); + Map readIdentifyIdentifyTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readIdentifyTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTypeCommandParams); + result.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.IdentifyCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIdentifyClusterGeneratedCommandListAttributeCallback(), + readIdentifyGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readIdentifyGeneratedCommandListAttributeInteractionInfo); + Map readIdentifyAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.IdentifyCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIdentifyClusterAcceptedCommandListAttributeCallback(), + readIdentifyAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readIdentifyAcceptedCommandListAttributeInteractionInfo); + Map readIdentifyEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readEventListAttribute( + (ChipClusters.IdentifyCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIdentifyClusterEventListAttributeCallback(), + readIdentifyEventListCommandParams); + result.put("readEventListAttribute", readIdentifyEventListAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), + readIdentifyAttributeListCommandParams); + result.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIdentifyFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readIdentifyFeatureMapAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - private static Map readIdentifyInteractionInfo() { - Map result = new LinkedHashMap<>();Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams - ); - result.put("readIdentifyTimeAttribute", readIdentifyIdentifyTimeAttributeInteractionInfo); - Map readIdentifyIdentifyTypeCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readIdentifyTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTypeCommandParams - ); - result.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.IdentifyCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIdentifyClusterGeneratedCommandListAttributeCallback(), - readIdentifyGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readIdentifyGeneratedCommandListAttributeInteractionInfo); - Map readIdentifyAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.IdentifyCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIdentifyClusterAcceptedCommandListAttributeCallback(), - readIdentifyAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readIdentifyAcceptedCommandListAttributeInteractionInfo); - Map readIdentifyEventListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readEventListAttribute( - (ChipClusters.IdentifyCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIdentifyClusterEventListAttributeCallback(), - readIdentifyEventListCommandParams - ); - result.put("readEventListAttribute", readIdentifyEventListAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( - (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIdentifyFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readIdentifyFeatureMapAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readGroupsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readGroupsNameSupportCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams - ); - result.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.GroupsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupsClusterGeneratedCommandListAttributeCallback(), - readGroupsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readGroupsGeneratedCommandListAttributeInteractionInfo); - Map readGroupsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.GroupsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupsClusterAcceptedCommandListAttributeCallback(), - readGroupsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readGroupsAcceptedCommandListAttributeInteractionInfo); - Map readGroupsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readEventListAttribute( - (ChipClusters.GroupsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupsClusterEventListAttributeCallback(), - readGroupsEventListCommandParams - ); - result.put("readEventListAttribute", readGroupsEventListAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( - (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGroupsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readGroupsFeatureMapAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readScenesInteractionInfo() { - Map result = new LinkedHashMap<>();Map readScenesSceneCountCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams - ); - result.put("readSceneCountAttribute", readScenesSceneCountAttributeInteractionInfo); - Map readScenesCurrentSceneCommandParams = new LinkedHashMap(); - InteractionInfo readScenesCurrentSceneAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readCurrentSceneAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesCurrentSceneCommandParams - ); - result.put("readCurrentSceneAttribute", readScenesCurrentSceneAttributeInteractionInfo); - Map readScenesCurrentGroupCommandParams = new LinkedHashMap(); - InteractionInfo readScenesCurrentGroupAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readCurrentGroupAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesCurrentGroupCommandParams - ); - result.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneValidAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readScenesSceneValidCommandParams - ); - result.put("readSceneValidAttribute", readScenesSceneValidAttributeInteractionInfo); - Map readScenesNameSupportCommandParams = new LinkedHashMap(); - InteractionInfo readScenesNameSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readNameSupportAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesNameSupportCommandParams - ); - result.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesLastConfiguredByCommandParams = new LinkedHashMap(); - InteractionInfo readScenesLastConfiguredByAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readLastConfiguredByAttribute( - (ChipClusters.ScenesCluster.LastConfiguredByAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterLastConfiguredByAttributeCallback(), - readScenesLastConfiguredByCommandParams - ); - result.put("readLastConfiguredByAttribute", readScenesLastConfiguredByAttributeInteractionInfo); - Map readScenesGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ScenesCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterGeneratedCommandListAttributeCallback(), - readScenesGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readScenesGeneratedCommandListAttributeInteractionInfo); - Map readScenesAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ScenesCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterAcceptedCommandListAttributeCallback(), - readScenesAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readScenesAcceptedCommandListAttributeInteractionInfo); - Map readScenesEventListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readEventListAttribute( - (ChipClusters.ScenesCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterEventListAttributeCallback(), - readScenesEventListCommandParams - ); - result.put("readEventListAttribute", readScenesEventListAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( - (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readScenesFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readScenesFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readScenesFeatureMapAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOnOffInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOnOffOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams - ); - result.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readGlobalSceneControlAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffGlobalSceneControlCommandParams - ); - result.put("readGlobalSceneControlAttribute", readOnOffGlobalSceneControlAttributeInteractionInfo); - Map readOnOffOnTimeCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffOnTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readOnTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffOnTimeCommandParams - ); - result.put("readOnTimeAttribute", readOnOffOnTimeAttributeInteractionInfo); - Map readOnOffOffWaitTimeCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffOffWaitTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readOffWaitTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffOffWaitTimeCommandParams - ); - result.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( - (ChipClusters.OnOffCluster.StartUpOnOffAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterStartUpOnOffAttributeCallback(), - readOnOffStartUpOnOffCommandParams - ); - result.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OnOffCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterGeneratedCommandListAttributeCallback(), - readOnOffGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOnOffGeneratedCommandListAttributeInteractionInfo); - Map readOnOffAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OnOffCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterAcceptedCommandListAttributeCallback(), - readOnOffAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOnOffAcceptedCommandListAttributeInteractionInfo); - Map readOnOffEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readEventListAttribute( - (ChipClusters.OnOffCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterEventListAttributeCallback(), - readOnOffEventListCommandParams - ); - result.put("readEventListAttribute", readOnOffEventListAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( - (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOnOffFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOnOffFeatureMapAttributeInteractionInfo); - Map readOnOffClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOnOffSwitchConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams - ); - result.put("readSwitchTypeAttribute", readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo); - Map readOnOffSwitchConfigurationSwitchActionsCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchActionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchActionsCommandParams - ); - result.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map readOnOffSwitchConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterGeneratedCommandListAttributeCallback(), - readOnOffSwitchConfigurationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAcceptedCommandListAttributeCallback(), - readOnOffSwitchConfigurationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readEventListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterEventListAttributeCallback(), - readOnOffSwitchConfigurationEventListCommandParams - ); - result.put("readEventListAttribute", readOnOffSwitchConfigurationEventListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOnOffSwitchConfigurationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readLevelControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( - (ChipClusters.LevelControlCluster.CurrentLevelAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterCurrentLevelAttributeCallback(), - readLevelControlCurrentLevelCommandParams - ); - result.put("readCurrentLevelAttribute", readLevelControlCurrentLevelAttributeInteractionInfo); - Map readLevelControlRemainingTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlRemainingTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readRemainingTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlRemainingTimeCommandParams - ); - result.put("readRemainingTimeAttribute", readLevelControlRemainingTimeAttributeInteractionInfo); - Map readLevelControlMinLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlMinLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readMinLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMinLevelCommandParams - ); - result.put("readMinLevelAttribute", readLevelControlMinLevelAttributeInteractionInfo); - Map readLevelControlMaxLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlMaxLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readMaxLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMaxLevelCommandParams - ); - result.put("readMaxLevelAttribute", readLevelControlMaxLevelAttributeInteractionInfo); - Map readLevelControlCurrentFrequencyCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlCurrentFrequencyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readCurrentFrequencyAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentFrequencyCommandParams - ); - result.put("readCurrentFrequencyAttribute", readLevelControlCurrentFrequencyAttributeInteractionInfo); - Map readLevelControlMinFrequencyCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlMinFrequencyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readMinFrequencyAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMinFrequencyCommandParams - ); - result.put("readMinFrequencyAttribute", readLevelControlMinFrequencyAttributeInteractionInfo); - Map readLevelControlMaxFrequencyCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlMaxFrequencyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readMaxFrequencyAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlMaxFrequencyCommandParams - ); - result.put("readMaxFrequencyAttribute", readLevelControlMaxFrequencyAttributeInteractionInfo); - Map readLevelControlOptionsCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOptionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOptionsCommandParams - ); - result.put("readOptionsAttribute", readLevelControlOptionsAttributeInteractionInfo); - Map readLevelControlOnOffTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnOffTransitionTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnOffTransitionTimeCommandParams - ); - result.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( - (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterOnLevelAttributeCallback(), - readLevelControlOnLevelCommandParams - ); - result.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterOnTransitionTimeAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams - ); - result.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterOffTransitionTimeAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams - ); - result.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( - (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterDefaultMoveRateAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams - ); - result.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( - (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterStartUpCurrentLevelAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams - ); - result.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.LevelControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterGeneratedCommandListAttributeCallback(), - readLevelControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readLevelControlGeneratedCommandListAttributeInteractionInfo); - Map readLevelControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.LevelControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterAcceptedCommandListAttributeCallback(), - readLevelControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readLevelControlAcceptedCommandListAttributeInteractionInfo); - Map readLevelControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readEventListAttribute( - (ChipClusters.LevelControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterEventListAttributeCallback(), - readLevelControlEventListCommandParams - ); - result.put("readEventListAttribute", readLevelControlEventListAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readLevelControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readLevelControlFeatureMapAttributeInteractionInfo); - Map readLevelControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBinaryInputBasicInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBinaryInputBasicActiveTextCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicActiveTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readActiveTextAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBinaryInputBasicActiveTextCommandParams - ); - result.put("readActiveTextAttribute", readBinaryInputBasicActiveTextAttributeInteractionInfo); - Map readBinaryInputBasicDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readDescriptionAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBinaryInputBasicDescriptionCommandParams - ); - result.put("readDescriptionAttribute", readBinaryInputBasicDescriptionAttributeInteractionInfo); - Map readBinaryInputBasicInactiveTextCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicInactiveTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readInactiveTextAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBinaryInputBasicInactiveTextCommandParams - ); - result.put("readInactiveTextAttribute", readBinaryInputBasicInactiveTextAttributeInteractionInfo); - Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams - ); - result.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPolarityCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPolarityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readPolarityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicPolarityCommandParams - ); - result.put("readPolarityAttribute", readBinaryInputBasicPolarityAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams - ); - result.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicReliabilityCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicReliabilityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readReliabilityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicReliabilityCommandParams - ); - result.put("readReliabilityAttribute", readBinaryInputBasicReliabilityAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams - ); - result.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicApplicationTypeCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicApplicationTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readApplicationTypeAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBinaryInputBasicApplicationTypeCommandParams - ); - result.put("readApplicationTypeAttribute", readBinaryInputBasicApplicationTypeAttributeInteractionInfo); - Map readBinaryInputBasicGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BinaryInputBasicCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterGeneratedCommandListAttributeCallback(), - readBinaryInputBasicGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo); - Map readBinaryInputBasicAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BinaryInputBasicCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAcceptedCommandListAttributeCallback(), - readBinaryInputBasicAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo); - Map readBinaryInputBasicEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readEventListAttribute( - (ChipClusters.BinaryInputBasicCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterEventListAttributeCallback(), - readBinaryInputBasicEventListCommandParams - ); - result.put("readEventListAttribute", readBinaryInputBasicEventListAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( - (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBinaryInputBasicFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBinaryInputBasicFeatureMapAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readPulseWidthModulationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readPulseWidthModulationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.PulseWidthModulationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterGeneratedCommandListAttributeCallback(), - readPulseWidthModulationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo); - Map readPulseWidthModulationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.PulseWidthModulationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterAcceptedCommandListAttributeCallback(), - readPulseWidthModulationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo); - Map readPulseWidthModulationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readPulseWidthModulationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster).readEventListAttribute( - (ChipClusters.PulseWidthModulationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterEventListAttributeCallback(), - readPulseWidthModulationEventListCommandParams - ); - result.put("readEventListAttribute", readPulseWidthModulationEventListAttributeInteractionInfo); - Map readPulseWidthModulationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPulseWidthModulationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster).readAttributeListAttribute( - (ChipClusters.PulseWidthModulationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPulseWidthModulationClusterAttributeListAttributeCallback(), - readPulseWidthModulationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readPulseWidthModulationAttributeListAttributeInteractionInfo); - Map readPulseWidthModulationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPulseWidthModulationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPulseWidthModulationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readPulseWidthModulationFeatureMapAttributeInteractionInfo); - Map readPulseWidthModulationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPulseWidthModulationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PulseWidthModulationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPulseWidthModulationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readPulseWidthModulationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readDescriptorInteractionInfo() { - Map result = new LinkedHashMap<>();Map readDescriptorDeviceTypeListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorDeviceTypeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readDeviceTypeListAttribute( - (ChipClusters.DescriptorCluster.DeviceTypeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceTypeListAttributeCallback(), - readDescriptorDeviceTypeListCommandParams - ); - result.put("readDeviceTypeListAttribute", readDescriptorDeviceTypeListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( - (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams - ); - result.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClientListAttribute( - (ChipClusters.DescriptorCluster.ClientListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterClientListAttributeCallback(), - readDescriptorClientListCommandParams - ); - result.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readPartsListAttribute( - (ChipClusters.DescriptorCluster.PartsListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterPartsListAttributeCallback(), - readDescriptorPartsListCommandParams - ); - result.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.DescriptorCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterGeneratedCommandListAttributeCallback(), - readDescriptorGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readDescriptorGeneratedCommandListAttributeInteractionInfo); - Map readDescriptorAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.DescriptorCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterAcceptedCommandListAttributeCallback(), - readDescriptorAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readDescriptorAcceptedCommandListAttributeInteractionInfo); - Map readDescriptorEventListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readEventListAttribute( - (ChipClusters.DescriptorCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterEventListAttributeCallback(), - readDescriptorEventListCommandParams - ); - result.put("readEventListAttribute", readDescriptorEventListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( - (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDescriptorFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readDescriptorFeatureMapAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBindingInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBindingBindingCommandParams = new LinkedHashMap(); - InteractionInfo readBindingBindingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readBindingAttribute( - (ChipClusters.BindingCluster.BindingAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterBindingAttributeCallback(), - readBindingBindingCommandParams - ); - result.put("readBindingAttribute", readBindingBindingAttributeInteractionInfo); - Map readBindingGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BindingCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterGeneratedCommandListAttributeCallback(), - readBindingGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBindingGeneratedCommandListAttributeInteractionInfo); - Map readBindingAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BindingCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterAcceptedCommandListAttributeCallback(), - readBindingAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBindingAcceptedCommandListAttributeInteractionInfo); - Map readBindingEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readEventListAttribute( - (ChipClusters.BindingCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterEventListAttributeCallback(), - readBindingEventListCommandParams - ); - result.put("readEventListAttribute", readBindingEventListAttributeInteractionInfo); - Map readBindingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( - (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBindingFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBindingFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBindingFeatureMapAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readAccessControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readAccessControlAclCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAclAttribute( - (ChipClusters.AccessControlCluster.AclAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAclAttributeCallback(), - readAccessControlAclCommandParams - ); - result.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readExtensionAttribute( - (ChipClusters.AccessControlCluster.ExtensionAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterExtensionAttributeCallback(), - readAccessControlExtensionCommandParams - ); - result.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlSubjectsPerAccessControlEntryCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readSubjectsPerAccessControlEntryAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlSubjectsPerAccessControlEntryCommandParams - ); - result.put("readSubjectsPerAccessControlEntryAttribute", readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo); - Map readAccessControlTargetsPerAccessControlEntryCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readTargetsPerAccessControlEntryAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlTargetsPerAccessControlEntryCommandParams - ); - result.put("readTargetsPerAccessControlEntryAttribute", readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo); - Map readAccessControlAccessControlEntriesPerFabricCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAccessControlEntriesPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlAccessControlEntriesPerFabricCommandParams - ); - result.put("readAccessControlEntriesPerFabricAttribute", readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo); - Map readAccessControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.AccessControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterGeneratedCommandListAttributeCallback(), - readAccessControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readAccessControlGeneratedCommandListAttributeInteractionInfo); - Map readAccessControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.AccessControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAcceptedCommandListAttributeCallback(), - readAccessControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readAccessControlAcceptedCommandListAttributeInteractionInfo); - Map readAccessControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readEventListAttribute( - (ChipClusters.AccessControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterEventListAttributeCallback(), - readAccessControlEventListCommandParams - ); - result.put("readEventListAttribute", readAccessControlEventListAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAccessControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readAccessControlFeatureMapAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readActionsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readActionsActionListCommandParams = new LinkedHashMap(); - InteractionInfo readActionsActionListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readActionListAttribute( - (ChipClusters.ActionsCluster.ActionListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterActionListAttributeCallback(), - readActionsActionListCommandParams - ); - result.put("readActionListAttribute", readActionsActionListAttributeInteractionInfo); - Map readActionsEndpointListsCommandParams = new LinkedHashMap(); - InteractionInfo readActionsEndpointListsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readEndpointListsAttribute( - (ChipClusters.ActionsCluster.EndpointListsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterEndpointListsAttributeCallback(), - readActionsEndpointListsCommandParams - ); - result.put("readEndpointListsAttribute", readActionsEndpointListsAttributeInteractionInfo); - Map readActionsSetupURLCommandParams = new LinkedHashMap(); - InteractionInfo readActionsSetupURLAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readSetupURLAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readActionsSetupURLCommandParams - ); - result.put("readSetupURLAttribute", readActionsSetupURLAttributeInteractionInfo); - Map readActionsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readActionsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ActionsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterGeneratedCommandListAttributeCallback(), - readActionsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readActionsGeneratedCommandListAttributeInteractionInfo); - Map readActionsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readActionsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ActionsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterAcceptedCommandListAttributeCallback(), - readActionsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readActionsAcceptedCommandListAttributeInteractionInfo); - Map readActionsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readActionsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readEventListAttribute( - (ChipClusters.ActionsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterEventListAttributeCallback(), - readActionsEventListCommandParams - ); - result.put("readEventListAttribute", readActionsEventListAttributeInteractionInfo); - Map readActionsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readActionsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readAttributeListAttribute( - (ChipClusters.ActionsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActionsClusterAttributeListAttributeCallback(), - readActionsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readActionsAttributeListAttributeInteractionInfo); - Map readActionsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readActionsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readActionsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readActionsFeatureMapAttributeInteractionInfo); - Map readActionsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActionsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActionsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readActionsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBasicInformationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBasicInformationDataModelRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationDataModelRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readDataModelRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationDataModelRevisionCommandParams - ); - result.put("readDataModelRevisionAttribute", readBasicInformationDataModelRevisionAttributeInteractionInfo); - Map readBasicInformationVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readVendorNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationVendorNameCommandParams - ); - result.put("readVendorNameAttribute", readBasicInformationVendorNameAttributeInteractionInfo); - Map readBasicInformationVendorIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationVendorIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readVendorIDAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationVendorIDCommandParams - ); - result.put("readVendorIDAttribute", readBasicInformationVendorIDAttributeInteractionInfo); - Map readBasicInformationProductNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationProductNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readProductNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationProductNameCommandParams - ); - result.put("readProductNameAttribute", readBasicInformationProductNameAttributeInteractionInfo); - Map readBasicInformationProductIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationProductIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readProductIDAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationProductIDCommandParams - ); - result.put("readProductIDAttribute", readBasicInformationProductIDAttributeInteractionInfo); - Map readBasicInformationNodeLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readNodeLabelAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationNodeLabelCommandParams - ); - result.put("readNodeLabelAttribute", readBasicInformationNodeLabelAttributeInteractionInfo); - Map readBasicInformationLocationCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readLocationAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationLocationCommandParams - ); - result.put("readLocationAttribute", readBasicInformationLocationAttributeInteractionInfo); - Map readBasicInformationHardwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationHardwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readHardwareVersionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationHardwareVersionCommandParams - ); - result.put("readHardwareVersionAttribute", readBasicInformationHardwareVersionAttributeInteractionInfo); - Map readBasicInformationHardwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readHardwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationHardwareVersionStringCommandParams - ); - result.put("readHardwareVersionStringAttribute", readBasicInformationHardwareVersionStringAttributeInteractionInfo); - Map readBasicInformationSoftwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationSoftwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readSoftwareVersionAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicInformationSoftwareVersionCommandParams - ); - result.put("readSoftwareVersionAttribute", readBasicInformationSoftwareVersionAttributeInteractionInfo); - Map readBasicInformationSoftwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readSoftwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationSoftwareVersionStringCommandParams - ); - result.put("readSoftwareVersionStringAttribute", readBasicInformationSoftwareVersionStringAttributeInteractionInfo); - Map readBasicInformationManufacturingDateCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationManufacturingDateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readManufacturingDateAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationManufacturingDateCommandParams - ); - result.put("readManufacturingDateAttribute", readBasicInformationManufacturingDateAttributeInteractionInfo); - Map readBasicInformationPartNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationPartNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readPartNumberAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationPartNumberCommandParams - ); - result.put("readPartNumberAttribute", readBasicInformationPartNumberAttributeInteractionInfo); - Map readBasicInformationProductURLCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationProductURLAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readProductURLAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationProductURLCommandParams - ); - result.put("readProductURLAttribute", readBasicInformationProductURLAttributeInteractionInfo); - Map readBasicInformationProductLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationProductLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readProductLabelAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationProductLabelCommandParams - ); - result.put("readProductLabelAttribute", readBasicInformationProductLabelAttributeInteractionInfo); - Map readBasicInformationSerialNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationSerialNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readSerialNumberAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationSerialNumberCommandParams - ); - result.put("readSerialNumberAttribute", readBasicInformationSerialNumberAttributeInteractionInfo); - Map readBasicInformationLocalConfigDisabledCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readLocalConfigDisabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicInformationLocalConfigDisabledCommandParams - ); - result.put("readLocalConfigDisabledAttribute", readBasicInformationLocalConfigDisabledAttributeInteractionInfo); - Map readBasicInformationReachableCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationReachableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readReachableAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicInformationReachableCommandParams - ); - result.put("readReachableAttribute", readBasicInformationReachableAttributeInteractionInfo); - Map readBasicInformationUniqueIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationUniqueIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readUniqueIDAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicInformationUniqueIDCommandParams - ); - result.put("readUniqueIDAttribute", readBasicInformationUniqueIDAttributeInteractionInfo); - Map readBasicInformationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BasicInformationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBasicInformationClusterGeneratedCommandListAttributeCallback(), - readBasicInformationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBasicInformationGeneratedCommandListAttributeInteractionInfo); - Map readBasicInformationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BasicInformationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBasicInformationClusterAcceptedCommandListAttributeCallback(), - readBasicInformationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBasicInformationAcceptedCommandListAttributeInteractionInfo); - Map readBasicInformationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readEventListAttribute( - (ChipClusters.BasicInformationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBasicInformationClusterEventListAttributeCallback(), - readBasicInformationEventListCommandParams - ); - result.put("readEventListAttribute", readBasicInformationEventListAttributeInteractionInfo); - Map readBasicInformationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readAttributeListAttribute( - (ChipClusters.BasicInformationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBasicInformationClusterAttributeListAttributeCallback(), - readBasicInformationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBasicInformationAttributeListAttributeInteractionInfo); - Map readBasicInformationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicInformationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBasicInformationFeatureMapAttributeInteractionInfo); - Map readBasicInformationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInformationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInformationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBasicInformationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOtaSoftwareUpdateProviderInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterGeneratedCommandListAttributeCallback(), - readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAcceptedCommandListAttributeCallback(), - readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readEventListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterEventListAttributeCallback(), - readOtaSoftwareUpdateProviderEventListCommandParams - ); - result.put("readEventListAttribute", readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOtaSoftwareUpdateProviderFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOtaSoftwareUpdateRequestorInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readDefaultOTAProvidersAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOTAProvidersAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterDefaultOTAProvidersAttributeCallback(), - readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams - ); - result.put("readDefaultOTAProvidersAttribute", readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdatePossibleAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams - ); - result.put("readUpdatePossibleAttribute", readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdateStateCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateCommandParams - ); - result.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterUpdateStateProgressAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams - ); - result.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterGeneratedCommandListAttributeCallback(), - readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAcceptedCommandListAttributeCallback(), - readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readEventListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterEventListAttributeCallback(), - readOtaSoftwareUpdateRequestorEventListCommandParams - ); - result.put("readEventListAttribute", readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOtaSoftwareUpdateRequestorFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readLocalizationConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams - ); - result.put("readActiveLocaleAttribute", readLocalizationConfigurationActiveLocaleAttributeInteractionInfo); - Map readLocalizationConfigurationSupportedLocalesCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readSupportedLocalesAttribute( - (ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback(), - readLocalizationConfigurationSupportedLocalesCommandParams - ); - result.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map readLocalizationConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.LocalizationConfigurationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterGeneratedCommandListAttributeCallback(), - readLocalizationConfigurationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readLocalizationConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.LocalizationConfigurationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterAcceptedCommandListAttributeCallback(), - readLocalizationConfigurationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readLocalizationConfigurationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readEventListAttribute( - (ChipClusters.LocalizationConfigurationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterEventListAttributeCallback(), - readLocalizationConfigurationEventListCommandParams - ); - result.put("readEventListAttribute", readLocalizationConfigurationEventListAttributeInteractionInfo); - Map readLocalizationConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readAttributeListAttribute( - (ChipClusters.LocalizationConfigurationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLocalizationConfigurationClusterAttributeListAttributeCallback(), - readLocalizationConfigurationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readLocalizationConfigurationAttributeListAttributeInteractionInfo); - Map readLocalizationConfigurationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readLocalizationConfigurationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readLocalizationConfigurationFeatureMapAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readTimeFormatLocalizationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams - ); - result.put("readHourFormatAttribute", readTimeFormatLocalizationHourFormatAttributeInteractionInfo); - Map readTimeFormatLocalizationActiveCalendarTypeCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readActiveCalendarTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationActiveCalendarTypeCommandParams - ); - result.put("readActiveCalendarTypeAttribute", readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); - Map readTimeFormatLocalizationSupportedCalendarTypesCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readSupportedCalendarTypesAttribute( - (ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback(), - readTimeFormatLocalizationSupportedCalendarTypesCommandParams - ); - result.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.TimeFormatLocalizationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterGeneratedCommandListAttributeCallback(), - readTimeFormatLocalizationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo); - Map readTimeFormatLocalizationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.TimeFormatLocalizationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterAcceptedCommandListAttributeCallback(), - readTimeFormatLocalizationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo); - Map readTimeFormatLocalizationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readEventListAttribute( - (ChipClusters.TimeFormatLocalizationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterEventListAttributeCallback(), - readTimeFormatLocalizationEventListCommandParams - ); - result.put("readEventListAttribute", readTimeFormatLocalizationEventListAttributeInteractionInfo); - Map readTimeFormatLocalizationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readAttributeListAttribute( - (ChipClusters.TimeFormatLocalizationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeFormatLocalizationClusterAttributeListAttributeCallback(), - readTimeFormatLocalizationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readTimeFormatLocalizationAttributeListAttributeInteractionInfo); - Map readTimeFormatLocalizationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTimeFormatLocalizationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readTimeFormatLocalizationFeatureMapAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readUnitLocalizationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams - ); - result.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.UnitLocalizationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterGeneratedCommandListAttributeCallback(), - readUnitLocalizationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readUnitLocalizationGeneratedCommandListAttributeInteractionInfo); - Map readUnitLocalizationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.UnitLocalizationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterAcceptedCommandListAttributeCallback(), - readUnitLocalizationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readUnitLocalizationAcceptedCommandListAttributeInteractionInfo); - Map readUnitLocalizationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readEventListAttribute( - (ChipClusters.UnitLocalizationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterEventListAttributeCallback(), - readUnitLocalizationEventListCommandParams - ); - result.put("readEventListAttribute", readUnitLocalizationEventListAttributeInteractionInfo); - Map readUnitLocalizationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readAttributeListAttribute( - (ChipClusters.UnitLocalizationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitLocalizationClusterAttributeListAttributeCallback(), - readUnitLocalizationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readUnitLocalizationAttributeListAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readUnitLocalizationFeatureMapAttributeInteractionInfo); - Map readUnitLocalizationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readPowerSourceConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readPowerSourceConfigurationSourcesCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationSourcesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readSourcesAttribute( - (ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback(), - readPowerSourceConfigurationSourcesCommandParams - ); - result.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map readPowerSourceConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterGeneratedCommandListAttributeCallback(), - readPowerSourceConfigurationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readPowerSourceConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAcceptedCommandListAttributeCallback(), - readPowerSourceConfigurationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readPowerSourceConfigurationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readEventListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterEventListAttributeCallback(), - readPowerSourceConfigurationEventListCommandParams - ); - result.put("readEventListAttribute", readPowerSourceConfigurationEventListAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceConfigurationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readPowerSourceConfigurationFeatureMapAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readPowerSourceInteractionInfo() { - Map result = new LinkedHashMap<>();Map readPowerSourceStatusCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams - ); - result.put("readStatusAttribute", readPowerSourceStatusAttributeInteractionInfo); - Map readPowerSourceOrderCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceOrderAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readOrderAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceOrderCommandParams - ); - result.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readDescriptionAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceDescriptionCommandParams - ); - result.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceWiredAssessedInputVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredAssessedInputVoltageAttribute( - (ChipClusters.PowerSourceCluster.WiredAssessedInputVoltageAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterWiredAssessedInputVoltageAttributeCallback(), - readPowerSourceWiredAssessedInputVoltageCommandParams - ); - result.put("readWiredAssessedInputVoltageAttribute", readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo); - Map readPowerSourceWiredAssessedInputFrequencyCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredAssessedInputFrequencyAttribute( - (ChipClusters.PowerSourceCluster.WiredAssessedInputFrequencyAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterWiredAssessedInputFrequencyAttributeCallback(), - readPowerSourceWiredAssessedInputFrequencyCommandParams - ); - result.put("readWiredAssessedInputFrequencyAttribute", readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo); - Map readPowerSourceWiredCurrentTypeCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredCurrentTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredCurrentTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceWiredCurrentTypeCommandParams - ); - result.put("readWiredCurrentTypeAttribute", readPowerSourceWiredCurrentTypeAttributeInteractionInfo); - Map readPowerSourceWiredAssessedCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredAssessedCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredAssessedCurrentAttribute( - (ChipClusters.PowerSourceCluster.WiredAssessedCurrentAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterWiredAssessedCurrentAttributeCallback(), - readPowerSourceWiredAssessedCurrentCommandParams - ); - result.put("readWiredAssessedCurrentAttribute", readPowerSourceWiredAssessedCurrentAttributeInteractionInfo); - Map readPowerSourceWiredNominalVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredNominalVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredNominalVoltageAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceWiredNominalVoltageCommandParams - ); - result.put("readWiredNominalVoltageAttribute", readPowerSourceWiredNominalVoltageAttributeInteractionInfo); - Map readPowerSourceWiredMaximumCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredMaximumCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredMaximumCurrentAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceWiredMaximumCurrentCommandParams - ); - result.put("readWiredMaximumCurrentAttribute", readPowerSourceWiredMaximumCurrentAttributeInteractionInfo); - Map readPowerSourceWiredPresentCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceWiredPresentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readWiredPresentAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceWiredPresentCommandParams - ); - result.put("readWiredPresentAttribute", readPowerSourceWiredPresentAttributeInteractionInfo); - Map readPowerSourceActiveWiredFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceActiveWiredFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readActiveWiredFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveWiredFaultsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveWiredFaultsAttributeCallback(), - readPowerSourceActiveWiredFaultsCommandParams - ); - result.put("readActiveWiredFaultsAttribute", readPowerSourceActiveWiredFaultsAttributeInteractionInfo); - Map readPowerSourceBatVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatVoltageAttribute( - (ChipClusters.PowerSourceCluster.BatVoltageAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatVoltageAttributeCallback(), - readPowerSourceBatVoltageCommandParams - ); - result.put("readBatVoltageAttribute", readPowerSourceBatVoltageAttributeInteractionInfo); - Map readPowerSourceBatPercentRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatPercentRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatPercentRemainingAttribute( - (ChipClusters.PowerSourceCluster.BatPercentRemainingAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatPercentRemainingAttributeCallback(), - readPowerSourceBatPercentRemainingCommandParams - ); - result.put("readBatPercentRemainingAttribute", readPowerSourceBatPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatTimeRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatTimeRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatTimeRemainingAttribute( - (ChipClusters.PowerSourceCluster.BatTimeRemainingAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatTimeRemainingAttributeCallback(), - readPowerSourceBatTimeRemainingCommandParams - ); - result.put("readBatTimeRemainingAttribute", readPowerSourceBatTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatChargeLevelCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatChargeLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatChargeLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatChargeLevelCommandParams - ); - result.put("readBatChargeLevelAttribute", readPowerSourceBatChargeLevelAttributeInteractionInfo); - Map readPowerSourceBatReplacementNeededCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatReplacementNeededAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatReplacementNeededAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceBatReplacementNeededCommandParams - ); - result.put("readBatReplacementNeededAttribute", readPowerSourceBatReplacementNeededAttributeInteractionInfo); - Map readPowerSourceBatReplaceabilityCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatReplaceabilityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatReplaceabilityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatReplaceabilityCommandParams - ); - result.put("readBatReplaceabilityAttribute", readPowerSourceBatReplaceabilityAttributeInteractionInfo); - Map readPowerSourceBatPresentCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatPresentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatPresentAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceBatPresentCommandParams - ); - result.put("readBatPresentAttribute", readPowerSourceBatPresentAttributeInteractionInfo); - Map readPowerSourceActiveBatFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readActiveBatFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveBatFaultsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatFaultsAttributeCallback(), - readPowerSourceActiveBatFaultsCommandParams - ); - result.put("readActiveBatFaultsAttribute", readPowerSourceActiveBatFaultsAttributeInteractionInfo); - Map readPowerSourceBatReplacementDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatReplacementDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatReplacementDescriptionAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceBatReplacementDescriptionCommandParams - ); - result.put("readBatReplacementDescriptionAttribute", readPowerSourceBatReplacementDescriptionAttributeInteractionInfo); - Map readPowerSourceBatCommonDesignationCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatCommonDesignationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatCommonDesignationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatCommonDesignationCommandParams - ); - result.put("readBatCommonDesignationAttribute", readPowerSourceBatCommonDesignationAttributeInteractionInfo); - Map readPowerSourceBatANSIDesignationCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatANSIDesignationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatANSIDesignationAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceBatANSIDesignationCommandParams - ); - result.put("readBatANSIDesignationAttribute", readPowerSourceBatANSIDesignationAttributeInteractionInfo); - Map readPowerSourceBatIECDesignationCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatIECDesignationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatIECDesignationAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readPowerSourceBatIECDesignationCommandParams - ); - result.put("readBatIECDesignationAttribute", readPowerSourceBatIECDesignationAttributeInteractionInfo); - Map readPowerSourceBatApprovedChemistryCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatApprovedChemistryAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatApprovedChemistryAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatApprovedChemistryCommandParams - ); - result.put("readBatApprovedChemistryAttribute", readPowerSourceBatApprovedChemistryAttributeInteractionInfo); - Map readPowerSourceBatCapacityCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatCapacityAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatCapacityCommandParams - ); - result.put("readBatCapacityAttribute", readPowerSourceBatCapacityAttributeInteractionInfo); - Map readPowerSourceBatQuantityCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatQuantityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatQuantityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatQuantityCommandParams - ); - result.put("readBatQuantityAttribute", readPowerSourceBatQuantityAttributeInteractionInfo); - Map readPowerSourceBatChargeStateCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatChargeStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatChargeStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatChargeStateCommandParams - ); - result.put("readBatChargeStateAttribute", readPowerSourceBatChargeStateAttributeInteractionInfo); - Map readPowerSourceBatTimeToFullChargeCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatTimeToFullChargeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatTimeToFullChargeAttribute( - (ChipClusters.PowerSourceCluster.BatTimeToFullChargeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatTimeToFullChargeAttributeCallback(), - readPowerSourceBatTimeToFullChargeCommandParams - ); - result.put("readBatTimeToFullChargeAttribute", readPowerSourceBatTimeToFullChargeAttributeInteractionInfo); - Map readPowerSourceBatFunctionalWhileChargingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatFunctionalWhileChargingAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readPowerSourceBatFunctionalWhileChargingCommandParams - ); - result.put("readBatFunctionalWhileChargingAttribute", readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo); - Map readPowerSourceBatChargingCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatChargingCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatChargingCurrentAttribute( - (ChipClusters.PowerSourceCluster.BatChargingCurrentAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatChargingCurrentAttributeCallback(), - readPowerSourceBatChargingCurrentCommandParams - ); - result.put("readBatChargingCurrentAttribute", readPowerSourceBatChargingCurrentAttributeInteractionInfo); - Map readPowerSourceActiveBatChargeFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readActiveBatChargeFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveBatChargeFaultsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatChargeFaultsAttributeCallback(), - readPowerSourceActiveBatChargeFaultsCommandParams - ); - result.put("readActiveBatChargeFaultsAttribute", readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo); - Map readPowerSourceGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.PowerSourceCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterGeneratedCommandListAttributeCallback(), - readPowerSourceGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readPowerSourceGeneratedCommandListAttributeInteractionInfo); - Map readPowerSourceAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.PowerSourceCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAcceptedCommandListAttributeCallback(), - readPowerSourceAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readPowerSourceAcceptedCommandListAttributeInteractionInfo); - Map readPowerSourceEventListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readEventListAttribute( - (ChipClusters.PowerSourceCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterEventListAttributeCallback(), - readPowerSourceEventListCommandParams - ); - result.put("readEventListAttribute", readPowerSourceEventListAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( - (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readPowerSourceFeatureMapAttributeInteractionInfo); - Map readPowerSourceClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readGeneralCommissioningInteractionInfo() { - Map result = new LinkedHashMap<>();Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams - ); - result.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams - ); - result.put("readRegulatoryConfigAttribute", readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo); - Map readGeneralCommissioningLocationCapabilityCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningLocationCapabilityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readLocationCapabilityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningLocationCapabilityCommandParams - ); - result.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map readGeneralCommissioningSupportsConcurrentConnectionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readSupportsConcurrentConnectionAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readGeneralCommissioningSupportsConcurrentConnectionCommandParams - ); - result.put("readSupportsConcurrentConnectionAttribute", readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo); - Map readGeneralCommissioningGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.GeneralCommissioningCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterGeneratedCommandListAttributeCallback(), - readGeneralCommissioningGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo); - Map readGeneralCommissioningAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.GeneralCommissioningCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAcceptedCommandListAttributeCallback(), - readGeneralCommissioningAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo); - Map readGeneralCommissioningEventListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readEventListAttribute( - (ChipClusters.GeneralCommissioningCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterEventListAttributeCallback(), - readGeneralCommissioningEventListCommandParams - ); - result.put("readEventListAttribute", readGeneralCommissioningEventListAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( - (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readGeneralCommissioningFeatureMapAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readNetworkCommissioningInteractionInfo() { - Map result = new LinkedHashMap<>();Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams - ); - result.put("readMaxNetworksAttribute", readNetworkCommissioningMaxNetworksAttributeInteractionInfo); - Map readNetworkCommissioningNetworksCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningNetworksAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readNetworksAttribute( - (ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterNetworksAttributeCallback(), - readNetworkCommissioningNetworksCommandParams - ); - result.put("readNetworksAttribute", readNetworkCommissioningNetworksAttributeInteractionInfo); - Map readNetworkCommissioningScanMaxTimeSecondsCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readScanMaxTimeSecondsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningScanMaxTimeSecondsCommandParams - ); - result.put("readScanMaxTimeSecondsAttribute", readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningConnectMaxTimeSecondsCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readConnectMaxTimeSecondsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningConnectMaxTimeSecondsCommandParams - ); - result.put("readConnectMaxTimeSecondsAttribute", readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readInterfaceEnabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readNetworkCommissioningInterfaceEnabledCommandParams - ); - result.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( - (ChipClusters.NetworkCommissioningCluster.LastNetworkingStatusAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterLastNetworkingStatusAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams - ); - result.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( - (ChipClusters.NetworkCommissioningCluster.LastNetworkIDAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterLastNetworkIDAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams - ); - result.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( - (ChipClusters.NetworkCommissioningCluster.LastConnectErrorValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterLastConnectErrorValueAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams - ); - result.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.NetworkCommissioningCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterGeneratedCommandListAttributeCallback(), - readNetworkCommissioningGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo); - Map readNetworkCommissioningAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.NetworkCommissioningCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterAcceptedCommandListAttributeCallback(), - readNetworkCommissioningAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo); - Map readNetworkCommissioningEventListCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readEventListAttribute( - (ChipClusters.NetworkCommissioningCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterEventListAttributeCallback(), - readNetworkCommissioningEventListCommandParams - ); - result.put("readEventListAttribute", readNetworkCommissioningEventListAttributeInteractionInfo); - Map readNetworkCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readAttributeListAttribute( - (ChipClusters.NetworkCommissioningCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedNetworkCommissioningClusterAttributeListAttributeCallback(), - readNetworkCommissioningAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readNetworkCommissioningAttributeListAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readNetworkCommissioningFeatureMapAttributeInteractionInfo); - Map readNetworkCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readDiagnosticLogsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readDiagnosticLogsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.DiagnosticLogsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterGeneratedCommandListAttributeCallback(), - readDiagnosticLogsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo); - Map readDiagnosticLogsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.DiagnosticLogsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAcceptedCommandListAttributeCallback(), - readDiagnosticLogsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo); - Map readDiagnosticLogsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readEventListAttribute( - (ChipClusters.DiagnosticLogsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterEventListAttributeCallback(), - readDiagnosticLogsEventListCommandParams - ); - result.put("readEventListAttribute", readDiagnosticLogsEventListAttributeInteractionInfo); - Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( - (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - Map readDiagnosticLogsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDiagnosticLogsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readDiagnosticLogsFeatureMapAttributeInteractionInfo); - Map readDiagnosticLogsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDiagnosticLogsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readDiagnosticLogsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readGeneralDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readGeneralDiagnosticsNetworkInterfacesCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readNetworkInterfacesAttribute( - (ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback(), - readGeneralDiagnosticsNetworkInterfacesCommandParams - ); - result.put("readNetworkInterfacesAttribute", readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo); - Map readGeneralDiagnosticsRebootCountCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsRebootCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readRebootCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsRebootCountCommandParams - ); - result.put("readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readUpTimeAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralDiagnosticsUpTimeCommandParams - ); - result.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTotalOperationalHoursAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralDiagnosticsTotalOperationalHoursCommandParams - ); - result.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonCommandParams - ); - result.put("readBootReasonAttribute", readGeneralDiagnosticsBootReasonAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams - ); - result.put("readActiveHardwareFaultsAttribute", readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveRadioFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveRadioFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback(), - readGeneralDiagnosticsActiveRadioFaultsCommandParams - ); - result.put("readActiveRadioFaultsAttribute", readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveNetworkFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveNetworkFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback(), - readGeneralDiagnosticsActiveNetworkFaultsCommandParams - ); - result.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsTestEventTriggersEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTestEventTriggersEnabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readGeneralDiagnosticsTestEventTriggersEnabledCommandParams - ); - result.put("readTestEventTriggersEnabledAttribute", readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo); - Map readGeneralDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readGeneralDiagnosticsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readGeneralDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readGeneralDiagnosticsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readGeneralDiagnosticsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readEventListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterEventListAttributeCallback(), - readGeneralDiagnosticsEventListCommandParams - ); - result.put("readEventListAttribute", readGeneralDiagnosticsEventListAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralDiagnosticsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readGeneralDiagnosticsFeatureMapAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readSoftwareDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readSoftwareDiagnosticsThreadMetricsCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readThreadMetricsAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback(), - readSoftwareDiagnosticsThreadMetricsCommandParams - ); - result.put("readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapFreeAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsCurrentHeapFreeCommandParams - ); - result.put("readCurrentHeapFreeAttribute", readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapUsedAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsCurrentHeapUsedCommandParams - ); - result.put("readCurrentHeapUsedAttribute", readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapHighWatermarkAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams - ); - result.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readSoftwareDiagnosticsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readSoftwareDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readSoftwareDiagnosticsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readSoftwareDiagnosticsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readEventListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterEventListAttributeCallback(), - readSoftwareDiagnosticsEventListCommandParams - ); - result.put("readEventListAttribute", readSoftwareDiagnosticsEventListAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSoftwareDiagnosticsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo); - Map readSoftwareDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSoftwareDiagnosticsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readThreadNetworkDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ChannelAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterChannelAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams - ); - result.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.RoutingRoleAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams - ); - result.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.NetworkNameAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNetworkNameAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams - ); - result.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.PanIdAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterPanIdAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams - ); - result.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ExtendedPanIdAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterExtendedPanIdAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams - ); - result.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.MeshLocalPrefixAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterMeshLocalPrefixAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams - ); - result.put("readMeshLocalPrefixAttribute", readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsOverrunCountCommandParams - ); - result.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableCommandParams - ); - result.put("readNeighborTableAttribute", readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableCommandParams - ); - result.put("readRouteTableAttribute", readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.PartitionIdAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterPartitionIdAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams - ); - result.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.WeightingAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterWeightingAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams - ); - result.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.DataVersionAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterDataVersionAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams - ); - result.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.StableDataVersionAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterStableDataVersionAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams - ); - result.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.LeaderRouterIdAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterLeaderRouterIdAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams - ); - result.put("readLeaderRouterIdAttribute", readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDetachedRoleCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDetachedRoleCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDetachedRoleCountCommandParams - ); - result.put("readDetachedRoleCountAttribute", readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChildRoleCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChildRoleCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChildRoleCountCommandParams - ); - result.put("readChildRoleCountAttribute", readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouterRoleCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouterRoleCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRouterRoleCountCommandParams - ); - result.put("readRouterRoleCountAttribute", readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRoleCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRoleCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRoleCountCommandParams - ); - result.put("readLeaderRoleCountAttribute", readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttachAttemptCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttachAttemptCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsAttachAttemptCountCommandParams - ); - result.put("readAttachAttemptCountAttribute", readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdChangeCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams - ); - result.put("readPartitionIdChangeCountAttribute", readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readBetterPartitionAttachAttemptCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams - ); - result.put("readBetterPartitionAttachAttemptCountAttribute", readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsParentChangeCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readParentChangeCountAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsParentChangeCountCommandParams - ); - result.put("readParentChangeCountAttribute", readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxTotalCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxTotalCountCommandParams - ); - result.put("readTxTotalCountAttribute", readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxUnicastCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxUnicastCountCommandParams - ); - result.put("readTxUnicastCountAttribute", readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBroadcastCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxBroadcastCountCommandParams - ); - result.put("readTxBroadcastCountAttribute", readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckRequestedCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams - ); - result.put("readTxAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckedCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxAckedCountCommandParams - ); - result.put("readTxAckedCountAttribute", readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxNoAckRequestedCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams - ); - result.put("readTxNoAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDataCountCommandParams - ); - result.put("readTxDataCountAttribute", readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataPollCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDataPollCountCommandParams - ); - result.put("readTxDataPollCountAttribute", readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxBeaconCountCommandParams - ); - result.put("readTxBeaconCountAttribute", readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconRequestCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams - ); - result.put("readTxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxOtherCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxOtherCountCommandParams - ); - result.put("readTxOtherCountAttribute", readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxRetryCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxRetryCountCommandParams - ); - result.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams - ); - result.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams - ); - result.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams - ); - result.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams - ); - result.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams - ); - result.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams - ); - result.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams - ); - result.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams - ); - result.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams - ); - result.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams - ); - result.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams - ); - result.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams - ); - result.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams - ); - result.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams - ); - result.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams - ); - result.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams - ); - result.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams - ); - result.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams - ); - result.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams - ); - result.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams - ); - result.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams - ); - result.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams - ); - result.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveTimestampAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveTimestampAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams - ); - result.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.PendingTimestampAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterPendingTimestampAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams - ); - result.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.DelayAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterDelayAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams - ); - result.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelPage0MaskCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelPage0MaskAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ChannelPage0MaskAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterChannelPage0MaskAttributeCallback(), - readThreadNetworkDiagnosticsChannelPage0MaskCommandParams - ); - result.put("readChannelPage0MaskAttribute", readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams - ); - result.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readThreadNetworkDiagnosticsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readThreadNetworkDiagnosticsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readEventListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterEventListAttributeCallback(), - readThreadNetworkDiagnosticsEventListCommandParams - ); - result.put("readEventListAttribute", readThreadNetworkDiagnosticsEventListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readWiFiNetworkDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.BssidAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterBssidAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams - ); - result.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.SecurityTypeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams - ); - result.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.WiFiVersionAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterWiFiVersionAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams - ); - result.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.ChannelNumberAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterChannelNumberAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams - ); - result.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.RssiAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterRssiAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams - ); - result.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconLostCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterBeaconLostCountAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams - ); - result.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconRxCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterBeaconRxCountAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams - ); - result.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketMulticastRxCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastRxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams - ); - result.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketMulticastTxCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastTxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams - ); - result.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketUnicastRxCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastRxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams - ); - result.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.PacketUnicastTxCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastTxCountAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams - ); - result.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.CurrentMaxRateAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterCurrentMaxRateAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams - ); - result.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.OverrunCountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterOverrunCountAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams - ); - result.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readEventListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterEventListAttributeCallback(), - readWiFiNetworkDiagnosticsEventListCommandParams - ); - result.put("readEventListAttribute", readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readEthernetNetworkDiagnosticsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.PHYRateAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterPHYRateAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams - ); - result.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.FullDuplexAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterFullDuplexAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams - ); - result.put("readFullDuplexAttribute", readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketRxCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsPacketRxCountCommandParams - ); - result.put("readPacketRxCountAttribute", readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketTxCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsPacketTxCountCommandParams - ); - result.put("readPacketTxCountAttribute", readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTxErrCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsTxErrCountCommandParams - ); - result.put("readTxErrCountAttribute", readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCollisionCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsCollisionCountCommandParams - ); - result.put("readCollisionCountAttribute", readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsOverrunCountCommandParams - ); - result.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.CarrierDetectAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterCarrierDetectAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams - ); - result.put("readCarrierDetectAttribute", readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTimeSinceResetAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsTimeSinceResetCommandParams - ); - result.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), - readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), - readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readEventListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterEventListAttributeCallback(), - readEthernetNetworkDiagnosticsEventListCommandParams - ); - result.put("readEventListAttribute", readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readEthernetNetworkDiagnosticsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readTimeSynchronizationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readTimeSynchronizationUTCTimeCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationUTCTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readUTCTimeAttribute( - (ChipClusters.TimeSynchronizationCluster.UTCTimeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterUTCTimeAttributeCallback(), - readTimeSynchronizationUTCTimeCommandParams - ); - result.put("readUTCTimeAttribute", readTimeSynchronizationUTCTimeAttributeInteractionInfo); - Map readTimeSynchronizationGranularityCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationGranularityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readGranularityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationGranularityCommandParams - ); - result.put("readGranularityAttribute", readTimeSynchronizationGranularityAttributeInteractionInfo); - Map readTimeSynchronizationTimeSourceCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeSourceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeSourceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationTimeSourceCommandParams - ); - result.put("readTimeSourceAttribute", readTimeSynchronizationTimeSourceAttributeInteractionInfo); - Map readTimeSynchronizationDefaultNTPCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationDefaultNTPAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readDefaultNTPAttribute( - (ChipClusters.TimeSynchronizationCluster.DefaultNTPAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterDefaultNTPAttributeCallback(), - readTimeSynchronizationDefaultNTPCommandParams - ); - result.put("readDefaultNTPAttribute", readTimeSynchronizationDefaultNTPAttributeInteractionInfo); - Map readTimeSynchronizationTimeZoneCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeZoneAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeZoneAttribute( - (ChipClusters.TimeSynchronizationCluster.TimeZoneAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterTimeZoneAttributeCallback(), - readTimeSynchronizationTimeZoneCommandParams - ); - result.put("readTimeZoneAttribute", readTimeSynchronizationTimeZoneAttributeInteractionInfo); - Map readTimeSynchronizationDSTOffsetCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationDSTOffsetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readDSTOffsetAttribute( - (ChipClusters.TimeSynchronizationCluster.DSTOffsetAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterDSTOffsetAttributeCallback(), - readTimeSynchronizationDSTOffsetCommandParams - ); - result.put("readDSTOffsetAttribute", readTimeSynchronizationDSTOffsetAttributeInteractionInfo); - Map readTimeSynchronizationLocalTimeCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationLocalTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readLocalTimeAttribute( - (ChipClusters.TimeSynchronizationCluster.LocalTimeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterLocalTimeAttributeCallback(), - readTimeSynchronizationLocalTimeCommandParams - ); - result.put("readLocalTimeAttribute", readTimeSynchronizationLocalTimeAttributeInteractionInfo); - Map readTimeSynchronizationTimeZoneDatabaseCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeZoneDatabaseAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationTimeZoneDatabaseCommandParams - ); - result.put("readTimeZoneDatabaseAttribute", readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo); - Map readTimeSynchronizationNTPServerAvailableCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readNTPServerAvailableAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTimeSynchronizationNTPServerAvailableCommandParams - ); - result.put("readNTPServerAvailableAttribute", readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo); - Map readTimeSynchronizationTimeZoneListMaxSizeCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readTimeZoneListMaxSizeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationTimeZoneListMaxSizeCommandParams - ); - result.put("readTimeZoneListMaxSizeAttribute", readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo); - Map readTimeSynchronizationDSTOffsetListMaxSizeCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readDSTOffsetListMaxSizeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationDSTOffsetListMaxSizeCommandParams - ); - result.put("readDSTOffsetListMaxSizeAttribute", readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo); - Map readTimeSynchronizationSupportsDNSResolveCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readSupportsDNSResolveAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTimeSynchronizationSupportsDNSResolveCommandParams - ); - result.put("readSupportsDNSResolveAttribute", readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo); - Map readTimeSynchronizationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.TimeSynchronizationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterGeneratedCommandListAttributeCallback(), - readTimeSynchronizationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo); - Map readTimeSynchronizationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.TimeSynchronizationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterAcceptedCommandListAttributeCallback(), - readTimeSynchronizationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo); - Map readTimeSynchronizationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readEventListAttribute( - (ChipClusters.TimeSynchronizationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterEventListAttributeCallback(), - readTimeSynchronizationEventListCommandParams - ); - result.put("readEventListAttribute", readTimeSynchronizationEventListAttributeInteractionInfo); - Map readTimeSynchronizationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readAttributeListAttribute( - (ChipClusters.TimeSynchronizationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTimeSynchronizationClusterAttributeListAttributeCallback(), - readTimeSynchronizationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readTimeSynchronizationAttributeListAttributeInteractionInfo); - Map readTimeSynchronizationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTimeSynchronizationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readTimeSynchronizationFeatureMapAttributeInteractionInfo); - Map readTimeSynchronizationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTimeSynchronizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeSynchronizationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeSynchronizationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readTimeSynchronizationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBridgedDeviceBasicInformationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBridgedDeviceBasicInformationVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readVendorNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationVendorNameCommandParams - ); - result.put("readVendorNameAttribute", readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationVendorIDCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readVendorIDAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicInformationVendorIDCommandParams - ); - result.put("readVendorIDAttribute", readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationProductNameCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readProductNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationProductNameCommandParams - ); - result.put("readProductNameAttribute", readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationNodeLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readNodeLabelAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationNodeLabelCommandParams - ); - result.put("readNodeLabelAttribute", readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationHardwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readHardwareVersionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicInformationHardwareVersionCommandParams - ); - result.put("readHardwareVersionAttribute", readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationHardwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readHardwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationHardwareVersionStringCommandParams - ); - result.put("readHardwareVersionStringAttribute", readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationSoftwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readSoftwareVersionAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBridgedDeviceBasicInformationSoftwareVersionCommandParams - ); - result.put("readSoftwareVersionAttribute", readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readSoftwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams - ); - result.put("readSoftwareVersionStringAttribute", readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationManufacturingDateCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readManufacturingDateAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationManufacturingDateCommandParams - ); - result.put("readManufacturingDateAttribute", readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationPartNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readPartNumberAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationPartNumberCommandParams - ); - result.put("readPartNumberAttribute", readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationProductURLCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readProductURLAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationProductURLCommandParams - ); - result.put("readProductURLAttribute", readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationProductLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readProductLabelAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationProductLabelCommandParams - ); - result.put("readProductLabelAttribute", readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationSerialNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readSerialNumberAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationSerialNumberCommandParams - ); - result.put("readSerialNumberAttribute", readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationReachableCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationReachableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readReachableAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBridgedDeviceBasicInformationReachableCommandParams - ); - result.put("readReachableAttribute", readBridgedDeviceBasicInformationReachableAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationUniqueIDCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readUniqueIDAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedDeviceBasicInformationUniqueIDCommandParams - ); - result.put("readUniqueIDAttribute", readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterGeneratedCommandListAttributeCallback(), - readBridgedDeviceBasicInformationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterAcceptedCommandListAttributeCallback(), - readBridgedDeviceBasicInformationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readEventListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterEventListAttributeCallback(), - readBridgedDeviceBasicInformationEventListCommandParams - ); - result.put("readEventListAttribute", readBridgedDeviceBasicInformationEventListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readAttributeListAttribute( - (ChipClusters.BridgedDeviceBasicInformationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicInformationClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicInformationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBridgedDeviceBasicInformationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo); - Map readBridgedDeviceBasicInformationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicInformationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readSwitchInteractionInfo() { - Map result = new LinkedHashMap<>();Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams - ); - result.put("readNumberOfPositionsAttribute", readSwitchNumberOfPositionsAttributeInteractionInfo); - Map readSwitchCurrentPositionCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchCurrentPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readCurrentPositionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchCurrentPositionCommandParams - ); - result.put("readCurrentPositionAttribute", readSwitchCurrentPositionAttributeInteractionInfo); - Map readSwitchMultiPressMaxCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchMultiPressMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readMultiPressMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchMultiPressMaxCommandParams - ); - result.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.SwitchCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSwitchClusterGeneratedCommandListAttributeCallback(), - readSwitchGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readSwitchGeneratedCommandListAttributeInteractionInfo); - Map readSwitchAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.SwitchCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSwitchClusterAcceptedCommandListAttributeCallback(), - readSwitchAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readSwitchAcceptedCommandListAttributeInteractionInfo); - Map readSwitchEventListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readEventListAttribute( - (ChipClusters.SwitchCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSwitchClusterEventListAttributeCallback(), - readSwitchEventListCommandParams - ); - result.put("readEventListAttribute", readSwitchEventListAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( - (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readSwitchFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readSwitchFeatureMapAttributeInteractionInfo); - Map readSwitchClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readAdministratorCommissioningInteractionInfo() { - Map result = new LinkedHashMap<>();Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams - ); - result.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( - (ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAdminFabricIndexAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams - ); - result.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( - (ChipClusters.AdministratorCommissioningCluster.AdminVendorIdAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAdminVendorIdAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams - ); - result.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map readAdministratorCommissioningGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.AdministratorCommissioningCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterGeneratedCommandListAttributeCallback(), - readAdministratorCommissioningGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo); - Map readAdministratorCommissioningAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.AdministratorCommissioningCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAcceptedCommandListAttributeCallback(), - readAdministratorCommissioningAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo); - Map readAdministratorCommissioningEventListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readEventListAttribute( - (ChipClusters.AdministratorCommissioningCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterEventListAttributeCallback(), - readAdministratorCommissioningEventListCommandParams - ); - result.put("readEventListAttribute", readAdministratorCommissioningEventListAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( - (ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAdministratorCommissioningFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readAdministratorCommissioningFeatureMapAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOperationalCredentialsInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOperationalCredentialsNOCsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsNOCsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readNOCsAttribute( - (ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterNOCsAttributeCallback(), - readOperationalCredentialsNOCsCommandParams - ); - result.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsAttribute( - (ChipClusters.OperationalCredentialsCluster.FabricsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsAttributeCallback(), - readOperationalCredentialsFabricsCommandParams - ); - result.put("readFabricsAttribute", readOperationalCredentialsFabricsAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams - ); - result.put("readSupportedFabricsAttribute", readOperationalCredentialsSupportedFabricsAttributeInteractionInfo); - Map readOperationalCredentialsCommissionedFabricsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readCommissionedFabricsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCommissionedFabricsCommandParams - ); - result.put("readCommissionedFabricsAttribute", readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo); - Map readOperationalCredentialsTrustedRootCertificatesCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readTrustedRootCertificatesAttribute( - (ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback(), - readOperationalCredentialsTrustedRootCertificatesCommandParams - ); - result.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams - ); - result.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OperationalCredentialsCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterGeneratedCommandListAttributeCallback(), - readOperationalCredentialsGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo); - Map readOperationalCredentialsAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OperationalCredentialsCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAcceptedCommandListAttributeCallback(), - readOperationalCredentialsAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo); - Map readOperationalCredentialsEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readEventListAttribute( - (ChipClusters.OperationalCredentialsCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterEventListAttributeCallback(), - readOperationalCredentialsEventListCommandParams - ); - result.put("readEventListAttribute", readOperationalCredentialsEventListAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( - (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOperationalCredentialsFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOperationalCredentialsFeatureMapAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readGroupKeyManagementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readGroupKeyManagementGroupKeyMapCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementGroupKeyMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readGroupKeyMapAttribute( - (ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback(), - readGroupKeyManagementGroupKeyMapCommandParams - ); - result.put("readGroupKeyMapAttribute", readGroupKeyManagementGroupKeyMapAttributeInteractionInfo); - Map readGroupKeyManagementGroupTableCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementGroupTableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readGroupTableAttribute( - (ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterGroupTableAttributeCallback(), - readGroupKeyManagementGroupTableCommandParams - ); - result.put("readGroupTableAttribute", readGroupKeyManagementGroupTableAttributeInteractionInfo); - Map readGroupKeyManagementMaxGroupsPerFabricCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readMaxGroupsPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementMaxGroupsPerFabricCommandParams - ); - result.put("readMaxGroupsPerFabricAttribute", readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementMaxGroupKeysPerFabricCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readMaxGroupKeysPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementMaxGroupKeysPerFabricCommandParams - ); - result.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.GroupKeyManagementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterGeneratedCommandListAttributeCallback(), - readGroupKeyManagementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo); - Map readGroupKeyManagementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.GroupKeyManagementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAcceptedCommandListAttributeCallback(), - readGroupKeyManagementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo); - Map readGroupKeyManagementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readEventListAttribute( - (ChipClusters.GroupKeyManagementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterEventListAttributeCallback(), - readGroupKeyManagementEventListCommandParams - ); - result.put("readEventListAttribute", readGroupKeyManagementEventListAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( - (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGroupKeyManagementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readGroupKeyManagementFeatureMapAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readFixedLabelInteractionInfo() { - Map result = new LinkedHashMap<>();Map readFixedLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readLabelListAttribute( - (ChipClusters.FixedLabelCluster.LabelListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterLabelListAttributeCallback(), - readFixedLabelLabelListCommandParams - ); - result.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.FixedLabelCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterGeneratedCommandListAttributeCallback(), - readFixedLabelGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readFixedLabelGeneratedCommandListAttributeInteractionInfo); - Map readFixedLabelAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.FixedLabelCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAcceptedCommandListAttributeCallback(), - readFixedLabelAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readFixedLabelAcceptedCommandListAttributeInteractionInfo); - Map readFixedLabelEventListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readEventListAttribute( - (ChipClusters.FixedLabelCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterEventListAttributeCallback(), - readFixedLabelEventListCommandParams - ); - result.put("readEventListAttribute", readFixedLabelEventListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( - (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFixedLabelFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readFixedLabelFeatureMapAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readUserLabelInteractionInfo() { - Map result = new LinkedHashMap<>();Map readUserLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readLabelListAttribute( - (ChipClusters.UserLabelCluster.LabelListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterLabelListAttributeCallback(), - readUserLabelLabelListCommandParams - ); - result.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.UserLabelCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterGeneratedCommandListAttributeCallback(), - readUserLabelGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readUserLabelGeneratedCommandListAttributeInteractionInfo); - Map readUserLabelAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.UserLabelCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterAcceptedCommandListAttributeCallback(), - readUserLabelAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readUserLabelAcceptedCommandListAttributeInteractionInfo); - Map readUserLabelEventListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readEventListAttribute( - (ChipClusters.UserLabelCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterEventListAttributeCallback(), - readUserLabelEventListCommandParams - ); - result.put("readEventListAttribute", readUserLabelEventListAttributeInteractionInfo); - Map readUserLabelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readAttributeListAttribute( - (ChipClusters.UserLabelCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUserLabelClusterAttributeListAttributeCallback(), - readUserLabelAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readUserLabelAttributeListAttributeInteractionInfo); - Map readUserLabelFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUserLabelFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readUserLabelFeatureMapAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readProxyConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readProxyConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ProxyConfigurationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterGeneratedCommandListAttributeCallback(), - readProxyConfigurationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readProxyConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readProxyConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ProxyConfigurationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterAcceptedCommandListAttributeCallback(), - readProxyConfigurationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readProxyConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readProxyConfigurationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyConfigurationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster).readEventListAttribute( - (ChipClusters.ProxyConfigurationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterEventListAttributeCallback(), - readProxyConfigurationEventListCommandParams - ); - result.put("readEventListAttribute", readProxyConfigurationEventListAttributeInteractionInfo); - Map readProxyConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster).readAttributeListAttribute( - (ChipClusters.ProxyConfigurationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyConfigurationClusterAttributeListAttributeCallback(), - readProxyConfigurationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readProxyConfigurationAttributeListAttributeInteractionInfo); - Map readProxyConfigurationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readProxyConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readProxyConfigurationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readProxyConfigurationFeatureMapAttributeInteractionInfo); - Map readProxyConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readProxyConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyConfigurationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readProxyConfigurationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readProxyConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readProxyDiscoveryInteractionInfo() { - Map result = new LinkedHashMap<>();Map readProxyDiscoveryGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ProxyDiscoveryCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterGeneratedCommandListAttributeCallback(), - readProxyDiscoveryGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo); - Map readProxyDiscoveryAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ProxyDiscoveryCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterAcceptedCommandListAttributeCallback(), - readProxyDiscoveryAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo); - Map readProxyDiscoveryEventListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyDiscoveryEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster).readEventListAttribute( - (ChipClusters.ProxyDiscoveryCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterEventListAttributeCallback(), - readProxyDiscoveryEventListCommandParams - ); - result.put("readEventListAttribute", readProxyDiscoveryEventListAttributeInteractionInfo); - Map readProxyDiscoveryAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyDiscoveryAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster).readAttributeListAttribute( - (ChipClusters.ProxyDiscoveryCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterAttributeListAttributeCallback(), - readProxyDiscoveryAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readProxyDiscoveryAttributeListAttributeInteractionInfo); - Map readProxyDiscoveryFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readProxyDiscoveryFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readProxyDiscoveryFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readProxyDiscoveryFeatureMapAttributeInteractionInfo); - Map readProxyDiscoveryClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readProxyDiscoveryClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyDiscoveryCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readProxyDiscoveryClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readProxyDiscoveryClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readProxyValidInteractionInfo() { - Map result = new LinkedHashMap<>();Map readProxyValidGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyValidGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ProxyValidCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyValidClusterGeneratedCommandListAttributeCallback(), - readProxyValidGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readProxyValidGeneratedCommandListAttributeInteractionInfo); - Map readProxyValidAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyValidAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ProxyValidCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyValidClusterAcceptedCommandListAttributeCallback(), - readProxyValidAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readProxyValidAcceptedCommandListAttributeInteractionInfo); - Map readProxyValidEventListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyValidEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster).readEventListAttribute( - (ChipClusters.ProxyValidCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyValidClusterEventListAttributeCallback(), - readProxyValidEventListCommandParams - ); - result.put("readEventListAttribute", readProxyValidEventListAttributeInteractionInfo); - Map readProxyValidAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readProxyValidAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster).readAttributeListAttribute( - (ChipClusters.ProxyValidCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedProxyValidClusterAttributeListAttributeCallback(), - readProxyValidAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readProxyValidAttributeListAttributeInteractionInfo); - Map readProxyValidFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readProxyValidFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readProxyValidFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readProxyValidFeatureMapAttributeInteractionInfo); - Map readProxyValidClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readProxyValidClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ProxyValidCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readProxyValidClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readProxyValidClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBooleanStateInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams - ); - result.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BooleanStateCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterGeneratedCommandListAttributeCallback(), - readBooleanStateGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBooleanStateGeneratedCommandListAttributeInteractionInfo); - Map readBooleanStateAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BooleanStateCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAcceptedCommandListAttributeCallback(), - readBooleanStateAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBooleanStateAcceptedCommandListAttributeInteractionInfo); - Map readBooleanStateEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readEventListAttribute( - (ChipClusters.BooleanStateCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterEventListAttributeCallback(), - readBooleanStateEventListCommandParams - ); - result.put("readEventListAttribute", readBooleanStateEventListAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( - (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBooleanStateFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBooleanStateFeatureMapAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readIcdManagementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readIcdManagementIdleModeIntervalCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementIdleModeIntervalAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readIdleModeIntervalAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementIdleModeIntervalCommandParams - ); - result.put("readIdleModeIntervalAttribute", readIcdManagementIdleModeIntervalAttributeInteractionInfo); - Map readIcdManagementActiveModeIntervalCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementActiveModeIntervalAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readActiveModeIntervalAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementActiveModeIntervalCommandParams - ); - result.put("readActiveModeIntervalAttribute", readIcdManagementActiveModeIntervalAttributeInteractionInfo); - Map readIcdManagementActiveModeThresholdCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementActiveModeThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readActiveModeThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIcdManagementActiveModeThresholdCommandParams - ); - result.put("readActiveModeThresholdAttribute", readIcdManagementActiveModeThresholdAttributeInteractionInfo); - Map readIcdManagementRegisteredClientsCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementRegisteredClientsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readRegisteredClientsAttribute( - (ChipClusters.IcdManagementCluster.RegisteredClientsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIcdManagementClusterRegisteredClientsAttributeCallback(), - readIcdManagementRegisteredClientsCommandParams - ); - result.put("readRegisteredClientsAttribute", readIcdManagementRegisteredClientsAttributeInteractionInfo); - Map readIcdManagementICDCounterCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementICDCounterAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readICDCounterAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementICDCounterCommandParams - ); - result.put("readICDCounterAttribute", readIcdManagementICDCounterAttributeInteractionInfo); - Map readIcdManagementClientsSupportedPerFabricCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readClientsSupportedPerFabricAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIcdManagementClientsSupportedPerFabricCommandParams - ); - result.put("readClientsSupportedPerFabricAttribute", readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo); - Map readIcdManagementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.IcdManagementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIcdManagementClusterGeneratedCommandListAttributeCallback(), - readIcdManagementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readIcdManagementGeneratedCommandListAttributeInteractionInfo); - Map readIcdManagementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.IcdManagementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIcdManagementClusterAcceptedCommandListAttributeCallback(), - readIcdManagementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readIcdManagementAcceptedCommandListAttributeInteractionInfo); - Map readIcdManagementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readEventListAttribute( - (ChipClusters.IcdManagementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIcdManagementClusterEventListAttributeCallback(), - readIcdManagementEventListCommandParams - ); - result.put("readEventListAttribute", readIcdManagementEventListAttributeInteractionInfo); - Map readIcdManagementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readAttributeListAttribute( - (ChipClusters.IcdManagementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIcdManagementClusterAttributeListAttributeCallback(), - readIcdManagementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readIcdManagementAttributeListAttributeInteractionInfo); - Map readIcdManagementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIcdManagementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readIcdManagementFeatureMapAttributeInteractionInfo); - Map readIcdManagementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIcdManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IcdManagementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIcdManagementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readIcdManagementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readModeSelectInteractionInfo() { - Map result = new LinkedHashMap<>();Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams - ); - result.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectStandardNamespaceCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectStandardNamespaceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readStandardNamespaceAttribute( - (ChipClusters.ModeSelectCluster.StandardNamespaceAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterStandardNamespaceAttributeCallback(), - readModeSelectStandardNamespaceCommandParams - ); - result.put("readStandardNamespaceAttribute", readModeSelectStandardNamespaceAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( - (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams - ); - result.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams - ); - result.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( - (ChipClusters.ModeSelectCluster.StartUpModeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterStartUpModeAttributeCallback(), - readModeSelectStartUpModeCommandParams - ); - result.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( - (ChipClusters.ModeSelectCluster.OnModeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterOnModeAttributeCallback(), - readModeSelectOnModeCommandParams - ); - result.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ModeSelectCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterGeneratedCommandListAttributeCallback(), - readModeSelectGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readModeSelectGeneratedCommandListAttributeInteractionInfo); - Map readModeSelectAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ModeSelectCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterAcceptedCommandListAttributeCallback(), - readModeSelectAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readModeSelectAcceptedCommandListAttributeInteractionInfo); - Map readModeSelectEventListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readEventListAttribute( - (ChipClusters.ModeSelectCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterEventListAttributeCallback(), - readModeSelectEventListCommandParams - ); - result.put("readEventListAttribute", readModeSelectEventListAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( - (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readModeSelectFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readModeSelectFeatureMapAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readTemperatureControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readTemperatureControlTemperatureSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlTemperatureSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readTemperatureSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlTemperatureSetpointCommandParams - ); - result.put("readTemperatureSetpointAttribute", readTemperatureControlTemperatureSetpointAttributeInteractionInfo); - Map readTemperatureControlMinTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlMinTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readMinTemperatureAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlMinTemperatureCommandParams - ); - result.put("readMinTemperatureAttribute", readTemperatureControlMinTemperatureAttributeInteractionInfo); - Map readTemperatureControlMaxTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlMaxTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readMaxTemperatureAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlMaxTemperatureCommandParams - ); - result.put("readMaxTemperatureAttribute", readTemperatureControlMaxTemperatureAttributeInteractionInfo); - Map readTemperatureControlStepCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlStepAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readStepAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlStepCommandParams - ); - result.put("readStepAttribute", readTemperatureControlStepAttributeInteractionInfo); - Map readTemperatureControlCurrentTemperatureLevelIndexCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readCurrentTemperatureLevelIndexAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlCurrentTemperatureLevelIndexCommandParams - ); - result.put("readCurrentTemperatureLevelIndexAttribute", readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo); - Map readTemperatureControlSupportedTemperatureLevelsCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readSupportedTemperatureLevelsAttribute( - (ChipClusters.TemperatureControlCluster.SupportedTemperatureLevelsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterSupportedTemperatureLevelsAttributeCallback(), - readTemperatureControlSupportedTemperatureLevelsCommandParams - ); - result.put("readSupportedTemperatureLevelsAttribute", readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo); - Map readTemperatureControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.TemperatureControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterGeneratedCommandListAttributeCallback(), - readTemperatureControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readTemperatureControlGeneratedCommandListAttributeInteractionInfo); - Map readTemperatureControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.TemperatureControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterAcceptedCommandListAttributeCallback(), - readTemperatureControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readTemperatureControlAcceptedCommandListAttributeInteractionInfo); - Map readTemperatureControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readEventListAttribute( - (ChipClusters.TemperatureControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterEventListAttributeCallback(), - readTemperatureControlEventListCommandParams - ); - result.put("readEventListAttribute", readTemperatureControlEventListAttributeInteractionInfo); - Map readTemperatureControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.TemperatureControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureControlClusterAttributeListAttributeCallback(), - readTemperatureControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readTemperatureControlAttributeListAttributeInteractionInfo); - Map readTemperatureControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTemperatureControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readTemperatureControlFeatureMapAttributeInteractionInfo); - Map readTemperatureControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readTemperatureControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readRefrigeratorAlarmInteractionInfo() { - Map result = new LinkedHashMap<>();Map readRefrigeratorAlarmMaskCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readMaskAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmMaskCommandParams - ); - result.put("readMaskAttribute", readRefrigeratorAlarmMaskAttributeInteractionInfo); - Map readRefrigeratorAlarmLatchCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmLatchAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readLatchAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmLatchCommandParams - ); - result.put("readLatchAttribute", readRefrigeratorAlarmLatchAttributeInteractionInfo); - Map readRefrigeratorAlarmStateCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readStateAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmStateCommandParams - ); - result.put("readStateAttribute", readRefrigeratorAlarmStateAttributeInteractionInfo); - Map readRefrigeratorAlarmGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterGeneratedCommandListAttributeCallback(), - readRefrigeratorAlarmGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo); - Map readRefrigeratorAlarmAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterAcceptedCommandListAttributeCallback(), - readRefrigeratorAlarmAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo); - Map readRefrigeratorAlarmEventListCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readEventListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterEventListAttributeCallback(), - readRefrigeratorAlarmEventListCommandParams - ); - result.put("readEventListAttribute", readRefrigeratorAlarmEventListAttributeInteractionInfo); - Map readRefrigeratorAlarmAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readAttributeListAttribute( - (ChipClusters.RefrigeratorAlarmCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRefrigeratorAlarmClusterAttributeListAttributeCallback(), - readRefrigeratorAlarmAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readRefrigeratorAlarmAttributeListAttributeInteractionInfo); - Map readRefrigeratorAlarmFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRefrigeratorAlarmFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readRefrigeratorAlarmFeatureMapAttributeInteractionInfo); - Map readRefrigeratorAlarmClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRefrigeratorAlarmClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readAirQualityInteractionInfo() { - Map result = new LinkedHashMap<>();Map readAirQualityAirQualityCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityAirQualityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readAirQualityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAirQualityAirQualityCommandParams - ); - result.put("readAirQualityAttribute", readAirQualityAirQualityAttributeInteractionInfo); - Map readAirQualityGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.AirQualityCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAirQualityClusterGeneratedCommandListAttributeCallback(), - readAirQualityGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readAirQualityGeneratedCommandListAttributeInteractionInfo); - Map readAirQualityAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.AirQualityCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAirQualityClusterAcceptedCommandListAttributeCallback(), - readAirQualityAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readAirQualityAcceptedCommandListAttributeInteractionInfo); - Map readAirQualityEventListCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readEventListAttribute( - (ChipClusters.AirQualityCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAirQualityClusterEventListAttributeCallback(), - readAirQualityEventListCommandParams - ); - result.put("readEventListAttribute", readAirQualityEventListAttributeInteractionInfo); - Map readAirQualityAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readAttributeListAttribute( - (ChipClusters.AirQualityCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAirQualityClusterAttributeListAttributeCallback(), - readAirQualityAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readAirQualityAttributeListAttributeInteractionInfo); - Map readAirQualityFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAirQualityFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readAirQualityFeatureMapAttributeInteractionInfo); - Map readAirQualityClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAirQualityClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AirQualityCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAirQualityClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readAirQualityClusterRevisionAttributeInteractionInfo); - - 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 readDishwasherAlarmInteractionInfo() { - Map result = new LinkedHashMap<>();Map readDishwasherAlarmMaskCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readMaskAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmMaskCommandParams - ); - result.put("readMaskAttribute", readDishwasherAlarmMaskAttributeInteractionInfo); - Map readDishwasherAlarmLatchCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmLatchAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readLatchAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmLatchCommandParams - ); - result.put("readLatchAttribute", readDishwasherAlarmLatchAttributeInteractionInfo); - Map readDishwasherAlarmStateCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readStateAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmStateCommandParams - ); - result.put("readStateAttribute", readDishwasherAlarmStateAttributeInteractionInfo); - Map readDishwasherAlarmGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.DishwasherAlarmCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterGeneratedCommandListAttributeCallback(), - readDishwasherAlarmGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo); - Map readDishwasherAlarmAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.DishwasherAlarmCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterAcceptedCommandListAttributeCallback(), - readDishwasherAlarmAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo); - Map readDishwasherAlarmEventListCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readEventListAttribute( - (ChipClusters.DishwasherAlarmCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterEventListAttributeCallback(), - readDishwasherAlarmEventListCommandParams - ); - result.put("readEventListAttribute", readDishwasherAlarmEventListAttributeInteractionInfo); - Map readDishwasherAlarmAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readAttributeListAttribute( - (ChipClusters.DishwasherAlarmCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDishwasherAlarmClusterAttributeListAttributeCallback(), - readDishwasherAlarmAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readDishwasherAlarmAttributeListAttributeInteractionInfo); - Map readDishwasherAlarmFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDishwasherAlarmFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readDishwasherAlarmFeatureMapAttributeInteractionInfo); - Map readDishwasherAlarmClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDishwasherAlarmClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDishwasherAlarmClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readDishwasherAlarmClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readHepaFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readHepaFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readHepaFilterMonitoringConditionAttributeInteractionInfo); - Map readHepaFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readHepaFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readHepaFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readHepaFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readHepaFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.HepaFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readHepaFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readHepaFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.HepaFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readHepaFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readHepaFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.HepaFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterEventListAttributeCallback(), - readHepaFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readHepaFilterMonitoringEventListAttributeInteractionInfo); - Map readHepaFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.HepaFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedHepaFilterMonitoringClusterAttributeListAttributeCallback(), - readHepaFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readHepaFilterMonitoringAttributeListAttributeInteractionInfo); - Map readHepaFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readHepaFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readHepaFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readHepaFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.HepaFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readHepaFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readActivatedCarbonFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readActivatedCarbonFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterEventListAttributeCallback(), - readActivatedCarbonFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.ActivatedCarbonFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedActivatedCarbonFilterMonitoringClusterAttributeListAttributeCallback(), - readActivatedCarbonFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readActivatedCarbonFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readActivatedCarbonFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readActivatedCarbonFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readCeramicFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readCeramicFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readCeramicFilterMonitoringConditionAttributeInteractionInfo); - Map readCeramicFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readCeramicFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readCeramicFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readCeramicFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readCeramicFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readCeramicFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readCeramicFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readCeramicFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readCeramicFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterEventListAttributeCallback(), - readCeramicFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readCeramicFilterMonitoringEventListAttributeInteractionInfo); - Map readCeramicFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.CeramicFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCeramicFilterMonitoringClusterAttributeListAttributeCallback(), - readCeramicFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readCeramicFilterMonitoringAttributeListAttributeInteractionInfo); - Map readCeramicFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readCeramicFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readCeramicFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.CeramicFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readCeramicFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readElectrostaticFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readElectrostaticFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readElectrostaticFilterMonitoringConditionAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readElectrostaticFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readElectrostaticFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterEventListAttributeCallback(), - readElectrostaticFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readElectrostaticFilterMonitoringEventListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.ElectrostaticFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectrostaticFilterMonitoringClusterAttributeListAttributeCallback(), - readElectrostaticFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectrostaticFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readElectrostaticFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectrostaticFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readUvFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readUvFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readUvFilterMonitoringConditionAttributeInteractionInfo); - Map readUvFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readUvFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readUvFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readUvFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUvFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readUvFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.UvFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readUvFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readUvFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.UvFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readUvFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readUvFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.UvFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterEventListAttributeCallback(), - readUvFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readUvFilterMonitoringEventListAttributeInteractionInfo); - Map readUvFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.UvFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUvFilterMonitoringClusterAttributeListAttributeCallback(), - readUvFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readUvFilterMonitoringAttributeListAttributeInteractionInfo); - Map readUvFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUvFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readUvFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readUvFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUvFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UvFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUvFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readUvFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readIonizingFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readIonizingFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readIonizingFilterMonitoringConditionAttributeInteractionInfo); - Map readIonizingFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readIonizingFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readIonizingFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readIonizingFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readIonizingFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readIonizingFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readIonizingFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readIonizingFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readIonizingFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterEventListAttributeCallback(), - readIonizingFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readIonizingFilterMonitoringEventListAttributeInteractionInfo); - Map readIonizingFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.IonizingFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIonizingFilterMonitoringClusterAttributeListAttributeCallback(), - readIonizingFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readIonizingFilterMonitoringAttributeListAttributeInteractionInfo); - Map readIonizingFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIonizingFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readIonizingFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IonizingFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIonizingFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readZeoliteFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readZeoliteFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readZeoliteFilterMonitoringConditionAttributeInteractionInfo); - Map readZeoliteFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readZeoliteFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readZeoliteFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readZeoliteFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readZeoliteFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readZeoliteFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readZeoliteFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterEventListAttributeCallback(), - readZeoliteFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readZeoliteFilterMonitoringEventListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.ZeoliteFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedZeoliteFilterMonitoringClusterAttributeListAttributeCallback(), - readZeoliteFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo); - Map readZeoliteFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readZeoliteFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readZeoliteFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readZeoliteFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOzoneFilterMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOzoneFilterMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readOzoneFilterMonitoringConditionAttributeInteractionInfo); - Map readOzoneFilterMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo); - Map readOzoneFilterMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo); - Map readOzoneFilterMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOzoneFilterMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readOzoneFilterMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterGeneratedCommandListAttributeCallback(), - readOzoneFilterMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readOzoneFilterMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterAcceptedCommandListAttributeCallback(), - readOzoneFilterMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readOzoneFilterMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterEventListAttributeCallback(), - readOzoneFilterMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readOzoneFilterMonitoringEventListAttributeInteractionInfo); - Map readOzoneFilterMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.OzoneFilterMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOzoneFilterMonitoringClusterAttributeListAttributeCallback(), - readOzoneFilterMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOzoneFilterMonitoringAttributeListAttributeInteractionInfo); - Map readOzoneFilterMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOzoneFilterMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo); - Map readOzoneFilterMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OzoneFilterMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOzoneFilterMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readWaterTankMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readWaterTankMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readWaterTankMonitoringConditionAttributeInteractionInfo); - Map readWaterTankMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo); - Map readWaterTankMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readWaterTankMonitoringChangeIndicationAttributeInteractionInfo); - Map readWaterTankMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readWaterTankMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readWaterTankMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.WaterTankMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterGeneratedCommandListAttributeCallback(), - readWaterTankMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readWaterTankMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.WaterTankMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterAcceptedCommandListAttributeCallback(), - readWaterTankMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readWaterTankMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.WaterTankMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterEventListAttributeCallback(), - readWaterTankMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readWaterTankMonitoringEventListAttributeInteractionInfo); - Map readWaterTankMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.WaterTankMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWaterTankMonitoringClusterAttributeListAttributeCallback(), - readWaterTankMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readWaterTankMonitoringAttributeListAttributeInteractionInfo); - Map readWaterTankMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWaterTankMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readWaterTankMonitoringFeatureMapAttributeInteractionInfo); - Map readWaterTankMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWaterTankMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WaterTankMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWaterTankMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readWaterTankMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readFuelTankMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readFuelTankMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readFuelTankMonitoringConditionAttributeInteractionInfo); - Map readFuelTankMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo); - Map readFuelTankMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readFuelTankMonitoringChangeIndicationAttributeInteractionInfo); - Map readFuelTankMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readFuelTankMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readFuelTankMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.FuelTankMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterGeneratedCommandListAttributeCallback(), - readFuelTankMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readFuelTankMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.FuelTankMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterAcceptedCommandListAttributeCallback(), - readFuelTankMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readFuelTankMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.FuelTankMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterEventListAttributeCallback(), - readFuelTankMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readFuelTankMonitoringEventListAttributeInteractionInfo); - Map readFuelTankMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.FuelTankMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFuelTankMonitoringClusterAttributeListAttributeCallback(), - readFuelTankMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readFuelTankMonitoringAttributeListAttributeInteractionInfo); - Map readFuelTankMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFuelTankMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readFuelTankMonitoringFeatureMapAttributeInteractionInfo); - Map readFuelTankMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFuelTankMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FuelTankMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFuelTankMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readFuelTankMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readInkCartridgeMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readInkCartridgeMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readInkCartridgeMonitoringConditionAttributeInteractionInfo); - Map readInkCartridgeMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); - Map readInkCartridgeMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo); - Map readInkCartridgeMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readInkCartridgeMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readInkCartridgeMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), - readInkCartridgeMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readInkCartridgeMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), - readInkCartridgeMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readInkCartridgeMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterEventListAttributeCallback(), - readInkCartridgeMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readInkCartridgeMonitoringEventListAttributeInteractionInfo); - Map readInkCartridgeMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.InkCartridgeMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedInkCartridgeMonitoringClusterAttributeListAttributeCallback(), - readInkCartridgeMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readInkCartridgeMonitoringAttributeListAttributeInteractionInfo); - Map readInkCartridgeMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readInkCartridgeMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo); - Map readInkCartridgeMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.InkCartridgeMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readInkCartridgeMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readTonerCartridgeMonitoringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readTonerCartridgeMonitoringConditionCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringConditionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readConditionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringConditionCommandParams - ); - result.put("readConditionAttribute", readTonerCartridgeMonitoringConditionAttributeInteractionInfo); - Map readTonerCartridgeMonitoringDegradationDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readDegradationDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringDegradationDirectionCommandParams - ); - result.put("readDegradationDirectionAttribute", readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); - Map readTonerCartridgeMonitoringChangeIndicationCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readChangeIndicationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringChangeIndicationCommandParams - ); - result.put("readChangeIndicationAttribute", readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo); - Map readTonerCartridgeMonitoringInPlaceIndicatorCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readInPlaceIndicatorAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTonerCartridgeMonitoringInPlaceIndicatorCommandParams - ); - result.put("readInPlaceIndicatorAttribute", readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); - Map readTonerCartridgeMonitoringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), - readTonerCartridgeMonitoringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), - readTonerCartridgeMonitoringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readEventListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterEventListAttributeCallback(), - readTonerCartridgeMonitoringEventListCommandParams - ); - result.put("readEventListAttribute", readTonerCartridgeMonitoringEventListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readAttributeListAttribute( - (ChipClusters.TonerCartridgeMonitoringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTonerCartridgeMonitoringClusterAttributeListAttributeCallback(), - readTonerCartridgeMonitoringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo); - Map readTonerCartridgeMonitoringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTonerCartridgeMonitoringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo); - Map readTonerCartridgeMonitoringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TonerCartridgeMonitoringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTonerCartridgeMonitoringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readDoorLockInteractionInfo() { - Map result = new LinkedHashMap<>();Map readDoorLockLockStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( - (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterLockStateAttributeCallback(), - readDoorLockLockStateCommandParams - ); - result.put("readLockStateAttribute", readDoorLockLockStateAttributeInteractionInfo); - Map readDoorLockLockTypeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLockTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLockTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockTypeCommandParams - ); - result.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readActuatorEnabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockActuatorEnabledCommandParams - ); - result.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( - (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterDoorStateAttributeCallback(), - readDoorLockDoorStateCommandParams - ); - result.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockDoorOpenEventsCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDoorOpenEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDoorOpenEventsAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockDoorOpenEventsCommandParams - ); - result.put("readDoorOpenEventsAttribute", readDoorLockDoorOpenEventsAttributeInteractionInfo); - Map readDoorLockDoorClosedEventsCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDoorClosedEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDoorClosedEventsAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockDoorClosedEventsCommandParams - ); - result.put("readDoorClosedEventsAttribute", readDoorLockDoorClosedEventsAttributeInteractionInfo); - Map readDoorLockOpenPeriodCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockOpenPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readOpenPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockOpenPeriodCommandParams - ); - result.put("readOpenPeriodAttribute", readDoorLockOpenPeriodAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams - ); - result.put("readNumberOfTotalUsersSupportedAttribute", readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo); - Map readDoorLockNumberOfPINUsersSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfPINUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfPINUsersSupportedCommandParams - ); - result.put("readNumberOfPINUsersSupportedAttribute", readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo); - Map readDoorLockNumberOfRFIDUsersSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfRFIDUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfRFIDUsersSupportedCommandParams - ); - result.put("readNumberOfRFIDUsersSupportedAttribute", readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo); - Map readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams - ); - result.put("readNumberOfWeekDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfYearDaySchedulesSupportedPerUserAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams - ); - result.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockNumberOfHolidaySchedulesSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfHolidaySchedulesSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfHolidaySchedulesSupportedCommandParams - ); - result.put("readNumberOfHolidaySchedulesSupportedAttribute", readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams - ); - result.put("readMaxPINCodeLengthAttribute", readDoorLockMaxPINCodeLengthAttributeInteractionInfo); - Map readDoorLockMinPINCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMinPINCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMinPINCodeLengthAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMinPINCodeLengthCommandParams - ); - result.put("readMinPINCodeLengthAttribute", readDoorLockMinPINCodeLengthAttributeInteractionInfo); - Map readDoorLockMaxRFIDCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMaxRFIDCodeLengthAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxRFIDCodeLengthCommandParams - ); - result.put("readMaxRFIDCodeLengthAttribute", readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockMinRFIDCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMinRFIDCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMinRFIDCodeLengthAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMinRFIDCodeLengthCommandParams - ); - result.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockCredentialRulesSupportCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockCredentialRulesSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readCredentialRulesSupportAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockCredentialRulesSupportCommandParams - ); - result.put("readCredentialRulesSupportAttribute", readDoorLockCredentialRulesSupportAttributeInteractionInfo); - Map readDoorLockNumberOfCredentialsSupportedPerUserCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfCredentialsSupportedPerUserAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfCredentialsSupportedPerUserCommandParams - ); - result.put("readNumberOfCredentialsSupportedPerUserAttribute", readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams - ); - result.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockLEDSettingsCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLEDSettingsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLEDSettingsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLEDSettingsCommandParams - ); - result.put("readLEDSettingsAttribute", readDoorLockLEDSettingsAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams - ); - result.put("readAutoRelockTimeAttribute", readDoorLockAutoRelockTimeAttributeInteractionInfo); - Map readDoorLockSoundVolumeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockSoundVolumeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readSoundVolumeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockSoundVolumeCommandParams - ); - result.put("readSoundVolumeAttribute", readDoorLockSoundVolumeAttributeInteractionInfo); - Map readDoorLockOperatingModeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockOperatingModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readOperatingModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockOperatingModeCommandParams - ); - result.put("readOperatingModeAttribute", readDoorLockOperatingModeAttributeInteractionInfo); - Map readDoorLockSupportedOperatingModesCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockSupportedOperatingModesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readSupportedOperatingModesAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockSupportedOperatingModesCommandParams - ); - result.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockDefaultConfigurationRegisterCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDefaultConfigurationRegisterAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDefaultConfigurationRegisterCommandParams - ); - result.put("readDefaultConfigurationRegisterAttribute", readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo); - Map readDoorLockEnableLocalProgrammingCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnableLocalProgrammingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnableLocalProgrammingAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableLocalProgrammingCommandParams - ); - result.put("readEnableLocalProgrammingAttribute", readDoorLockEnableLocalProgrammingAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams - ); - result.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnableInsideStatusLEDCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnableInsideStatusLEDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnableInsideStatusLEDAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableInsideStatusLEDCommandParams - ); - result.put("readEnableInsideStatusLEDAttribute", readDoorLockEnableInsideStatusLEDAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams - ); - result.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockLocalProgrammingFeaturesCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLocalProgrammingFeaturesAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLocalProgrammingFeaturesCommandParams - ); - result.put("readLocalProgrammingFeaturesAttribute", readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams - ); - result.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockUserCodeTemporaryDisableTimeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readUserCodeTemporaryDisableTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockUserCodeTemporaryDisableTimeCommandParams - ); - result.put("readUserCodeTemporaryDisableTimeAttribute", readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); - Map readDoorLockSendPINOverTheAirCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockSendPINOverTheAirAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readSendPINOverTheAirAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockSendPINOverTheAirCommandParams - ); - result.put("readSendPINOverTheAirAttribute", readDoorLockSendPINOverTheAirAttributeInteractionInfo); - Map readDoorLockRequirePINforRemoteOperationCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readRequirePINforRemoteOperationAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockRequirePINforRemoteOperationCommandParams - ); - result.put("readRequirePINforRemoteOperationAttribute", readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); - Map readDoorLockExpiringUserTimeoutCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockExpiringUserTimeoutAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readExpiringUserTimeoutAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockExpiringUserTimeoutCommandParams - ); - result.put("readExpiringUserTimeoutAttribute", readDoorLockExpiringUserTimeoutAttributeInteractionInfo); - Map readDoorLockGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.DoorLockCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterGeneratedCommandListAttributeCallback(), - readDoorLockGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readDoorLockGeneratedCommandListAttributeInteractionInfo); - Map readDoorLockAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.DoorLockCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterAcceptedCommandListAttributeCallback(), - readDoorLockAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readDoorLockAcceptedCommandListAttributeInteractionInfo); - Map readDoorLockEventListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEventListAttribute( - (ChipClusters.DoorLockCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterEventListAttributeCallback(), - readDoorLockEventListCommandParams - ); - result.put("readEventListAttribute", readDoorLockEventListAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( - (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readDoorLockFeatureMapAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readWindowCoveringInteractionInfo() { - Map result = new LinkedHashMap<>();Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams - ); - result.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringPhysicalClosedLimitLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readPhysicalClosedLimitLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringPhysicalClosedLimitLiftCommandParams - ); - result.put("readPhysicalClosedLimitLiftAttribute", readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo); - Map readWindowCoveringPhysicalClosedLimitTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readPhysicalClosedLimitTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringPhysicalClosedLimitTiltCommandParams - ); - result.put("readPhysicalClosedLimitTiltAttribute", readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionLiftAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams - ); - result.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionTiltAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams - ); - result.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringNumberOfActuationsLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readNumberOfActuationsLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringNumberOfActuationsLiftCommandParams - ); - result.put("readNumberOfActuationsLiftAttribute", readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo); - Map readWindowCoveringNumberOfActuationsTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readNumberOfActuationsTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringNumberOfActuationsTiltCommandParams - ); - result.put("readNumberOfActuationsTiltAttribute", readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams - ); - result.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionLiftPercentageAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams - ); - result.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionTiltPercentageAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams - ); - result.put("readCurrentPositionTiltPercentageAttribute", readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo); - Map readWindowCoveringOperationalStatusCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringOperationalStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readOperationalStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringOperationalStatusCommandParams - ); - result.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterTargetPositionLiftPercent100thsAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams - ); - result.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterTargetPositionTiltPercent100thsAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams - ); - result.put("readTargetPositionTiltPercent100thsAttribute", readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo); - Map readWindowCoveringEndProductTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringEndProductTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readEndProductTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringEndProductTypeCommandParams - ); - result.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionLiftPercent100thsAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams - ); - result.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterCurrentPositionTiltPercent100thsAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams - ); - result.put("readCurrentPositionTiltPercent100thsAttribute", readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo); - Map readWindowCoveringInstalledOpenLimitLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readInstalledOpenLimitLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledOpenLimitLiftCommandParams - ); - result.put("readInstalledOpenLimitLiftAttribute", readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo); - Map readWindowCoveringInstalledClosedLimitLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readInstalledClosedLimitLiftAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledClosedLimitLiftCommandParams - ); - result.put("readInstalledClosedLimitLiftAttribute", readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo); - Map readWindowCoveringInstalledOpenLimitTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readInstalledOpenLimitTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledOpenLimitTiltCommandParams - ); - result.put("readInstalledOpenLimitTiltAttribute", readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo); - Map readWindowCoveringInstalledClosedLimitTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readInstalledClosedLimitTiltAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringInstalledClosedLimitTiltCommandParams - ); - result.put("readInstalledClosedLimitTiltAttribute", readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo); - Map readWindowCoveringModeCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringModeCommandParams - ); - result.put("readModeAttribute", readWindowCoveringModeAttributeInteractionInfo); - Map readWindowCoveringSafetyStatusCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringSafetyStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readSafetyStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringSafetyStatusCommandParams - ); - result.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.WindowCoveringCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterGeneratedCommandListAttributeCallback(), - readWindowCoveringGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readWindowCoveringGeneratedCommandListAttributeInteractionInfo); - Map readWindowCoveringAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.WindowCoveringCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAcceptedCommandListAttributeCallback(), - readWindowCoveringAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readWindowCoveringAcceptedCommandListAttributeInteractionInfo); - Map readWindowCoveringEventListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readEventListAttribute( - (ChipClusters.WindowCoveringCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterEventListAttributeCallback(), - readWindowCoveringEventListCommandParams - ); - result.put("readEventListAttribute", readWindowCoveringEventListAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( - (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWindowCoveringFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readWindowCoveringFeatureMapAttributeInteractionInfo); - Map readWindowCoveringClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBarrierControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams - ); - result.put("readBarrierMovingStateAttribute", readBarrierControlBarrierMovingStateAttributeInteractionInfo); - Map readBarrierControlBarrierSafetyStatusCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierSafetyStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierSafetyStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierSafetyStatusCommandParams - ); - result.put("readBarrierSafetyStatusAttribute", readBarrierControlBarrierSafetyStatusAttributeInteractionInfo); - Map readBarrierControlBarrierCapabilitiesCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCapabilitiesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierCapabilitiesAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCapabilitiesCommandParams - ); - result.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierOpenEventsCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierOpenEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierOpenEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierOpenEventsCommandParams - ); - result.put("readBarrierOpenEventsAttribute", readBarrierControlBarrierOpenEventsAttributeInteractionInfo); - Map readBarrierControlBarrierCloseEventsCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCloseEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierCloseEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCloseEventsCommandParams - ); - result.put("readBarrierCloseEventsAttribute", readBarrierControlBarrierCloseEventsAttributeInteractionInfo); - Map readBarrierControlBarrierCommandOpenEventsCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierCommandOpenEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCommandOpenEventsCommandParams - ); - result.put("readBarrierCommandOpenEventsAttribute", readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); - Map readBarrierControlBarrierCommandCloseEventsCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierCommandCloseEventsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierCommandCloseEventsCommandParams - ); - result.put("readBarrierCommandCloseEventsAttribute", readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); - Map readBarrierControlBarrierOpenPeriodCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierOpenPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierOpenPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierOpenPeriodCommandParams - ); - result.put("readBarrierOpenPeriodAttribute", readBarrierControlBarrierOpenPeriodAttributeInteractionInfo); - Map readBarrierControlBarrierClosePeriodCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierClosePeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierClosePeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierClosePeriodCommandParams - ); - result.put("readBarrierClosePeriodAttribute", readBarrierControlBarrierClosePeriodAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams - ); - result.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BarrierControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterGeneratedCommandListAttributeCallback(), - readBarrierControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBarrierControlGeneratedCommandListAttributeInteractionInfo); - Map readBarrierControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BarrierControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAcceptedCommandListAttributeCallback(), - readBarrierControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBarrierControlAcceptedCommandListAttributeInteractionInfo); - Map readBarrierControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readEventListAttribute( - (ChipClusters.BarrierControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterEventListAttributeCallback(), - readBarrierControlEventListCommandParams - ); - result.put("readEventListAttribute", readBarrierControlEventListAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBarrierControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBarrierControlFeatureMapAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readPumpConfigurationAndControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxPressureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxPressureAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams - ); - result.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxSpeedAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxSpeedAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams - ); - result.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxFlowAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxFlowAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams - ); - result.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MinConstPressureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstPressureAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams - ); - result.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxConstPressureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstPressureAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams - ); - result.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MinCompPressureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinCompPressureAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams - ); - result.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxCompPressureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxCompPressureAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams - ); - result.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MinConstSpeedAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstSpeedAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams - ); - result.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxConstSpeedAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstSpeedAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams - ); - result.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MinConstFlowAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstFlowAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams - ); - result.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxConstFlowAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstFlowAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams - ); - result.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MinConstTempAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMinConstTempAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams - ); - result.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.MaxConstTempAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterMaxConstTempAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams - ); - result.put("readMaxConstTempAttribute", readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlPumpStatusCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPumpStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlPumpStatusCommandParams - ); - result.put("readPumpStatusAttribute", readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo); - Map readPumpConfigurationAndControlEffectiveOperationModeCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readEffectiveOperationModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlEffectiveOperationModeCommandParams - ); - result.put("readEffectiveOperationModeAttribute", readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlEffectiveControlModeCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readEffectiveControlModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlEffectiveControlModeCommandParams - ); - result.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.CapacityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterCapacityAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams - ); - result.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.SpeedAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterSpeedAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams - ); - result.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterLifetimeRunningHoursAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams - ); - result.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.PowerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterPowerAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams - ); - result.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterLifetimeEnergyConsumedAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams - ); - result.put("readLifetimeEnergyConsumedAttribute", readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); - Map readPumpConfigurationAndControlOperationModeCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlOperationModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readOperationModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlOperationModeCommandParams - ); - result.put("readOperationModeAttribute", readPumpConfigurationAndControlOperationModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlControlModeCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlControlModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readControlModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlControlModeCommandParams - ); - result.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterGeneratedCommandListAttributeCallback(), - readPumpConfigurationAndControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo); - Map readPumpConfigurationAndControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAcceptedCommandListAttributeCallback(), - readPumpConfigurationAndControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo); - Map readPumpConfigurationAndControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readEventListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterEventListAttributeCallback(), - readPumpConfigurationAndControlEventListCommandParams - ); - result.put("readEventListAttribute", readPumpConfigurationAndControlEventListAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo); - Map readPumpConfigurationAndControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readThermostatInteractionInfo() { - Map result = new LinkedHashMap<>();Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( - (ChipClusters.ThermostatCluster.LocalTemperatureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterLocalTemperatureAttributeCallback(), - readThermostatLocalTemperatureCommandParams - ); - result.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatOutdoorTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOutdoorTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOutdoorTemperatureAttribute( - (ChipClusters.ThermostatCluster.OutdoorTemperatureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterOutdoorTemperatureAttributeCallback(), - readThermostatOutdoorTemperatureCommandParams - ); - result.put("readOutdoorTemperatureAttribute", readThermostatOutdoorTemperatureAttributeInteractionInfo); - Map readThermostatOccupancyCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupancyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupancyAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupancyCommandParams - ); - result.put("readOccupancyAttribute", readThermostatOccupancyAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams - ); - result.put("readAbsMinHeatSetpointLimitAttribute", readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatAbsMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMaxHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMaxHeatSetpointLimitCommandParams - ); - result.put("readAbsMaxHeatSetpointLimitAttribute", readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatAbsMinCoolSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMinCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinCoolSetpointLimitCommandParams - ); - result.put("readAbsMinCoolSetpointLimitAttribute", readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatAbsMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMaxCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMaxCoolSetpointLimitCommandParams - ); - result.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatPICoolingDemandCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatPICoolingDemandAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readPICoolingDemandAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatPICoolingDemandCommandParams - ); - result.put("readPICoolingDemandAttribute", readThermostatPICoolingDemandAttributeInteractionInfo); - Map readThermostatPIHeatingDemandCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatPIHeatingDemandAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readPIHeatingDemandAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatPIHeatingDemandCommandParams - ); - result.put("readPIHeatingDemandAttribute", readThermostatPIHeatingDemandAttributeInteractionInfo); - Map readThermostatHVACSystemTypeConfigurationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readHVACSystemTypeConfigurationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatHVACSystemTypeConfigurationCommandParams - ); - result.put("readHVACSystemTypeConfigurationAttribute", readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); - Map readThermostatLocalTemperatureCalibrationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureCalibrationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureCalibrationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCalibrationCommandParams - ); - result.put("readLocalTemperatureCalibrationAttribute", readThermostatLocalTemperatureCalibrationAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams - ); - result.put("readOccupiedCoolingSetpointAttribute", readThermostatOccupiedCoolingSetpointAttributeInteractionInfo); - Map readThermostatOccupiedHeatingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedHeatingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedHeatingSetpointCommandParams - ); - result.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatUnoccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedCoolingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUnoccupiedCoolingSetpointCommandParams - ); - result.put("readUnoccupiedCoolingSetpointAttribute", readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); - Map readThermostatUnoccupiedHeatingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedHeatingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUnoccupiedHeatingSetpointCommandParams - ); - result.put("readUnoccupiedHeatingSetpointAttribute", readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams - ); - result.put("readMinHeatSetpointLimitAttribute", readThermostatMinHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMaxHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMaxHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMaxHeatSetpointLimitCommandParams - ); - result.put("readMaxHeatSetpointLimitAttribute", readThermostatMaxHeatSetpointLimitAttributeInteractionInfo); - Map readThermostatMinCoolSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMinCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMinCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinCoolSetpointLimitCommandParams - ); - result.put("readMinCoolSetpointLimitAttribute", readThermostatMinCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMaxCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMaxCoolSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMaxCoolSetpointLimitCommandParams - ); - result.put("readMaxCoolSetpointLimitAttribute", readThermostatMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatMinSetpointDeadBandCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMinSetpointDeadBandAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMinSetpointDeadBandAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinSetpointDeadBandCommandParams - ); - result.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatRemoteSensingCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatRemoteSensingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readRemoteSensingAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatRemoteSensingCommandParams - ); - result.put("readRemoteSensingAttribute", readThermostatRemoteSensingAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams - ); - result.put("readControlSequenceOfOperationAttribute", readThermostatControlSequenceOfOperationAttributeInteractionInfo); - Map readThermostatSystemModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatSystemModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readSystemModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatSystemModeCommandParams - ); - result.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatThermostatRunningModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatThermostatRunningModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readThermostatRunningModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatThermostatRunningModeCommandParams - ); - result.put("readThermostatRunningModeAttribute", readThermostatThermostatRunningModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams - ); - result.put("readStartOfWeekAttribute", readThermostatStartOfWeekAttributeInteractionInfo); - Map readThermostatNumberOfWeeklyTransitionsCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readNumberOfWeeklyTransitionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatNumberOfWeeklyTransitionsCommandParams - ); - result.put("readNumberOfWeeklyTransitionsAttribute", readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo); - Map readThermostatNumberOfDailyTransitionsCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatNumberOfDailyTransitionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readNumberOfDailyTransitionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatNumberOfDailyTransitionsCommandParams - ); - result.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatTemperatureSetpointHoldCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatTemperatureSetpointHoldAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readTemperatureSetpointHoldAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatTemperatureSetpointHoldCommandParams - ); - result.put("readTemperatureSetpointHoldAttribute", readThermostatTemperatureSetpointHoldAttributeInteractionInfo); - Map readThermostatTemperatureSetpointHoldDurationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readTemperatureSetpointHoldDurationAttribute( - (ChipClusters.ThermostatCluster.TemperatureSetpointHoldDurationAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterTemperatureSetpointHoldDurationAttributeCallback(), - readThermostatTemperatureSetpointHoldDurationCommandParams - ); - result.put("readTemperatureSetpointHoldDurationAttribute", readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); - Map readThermostatThermostatProgrammingOperationModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readThermostatProgrammingOperationModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatThermostatProgrammingOperationModeCommandParams - ); - result.put("readThermostatProgrammingOperationModeAttribute", readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); - Map readThermostatThermostatRunningStateCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatThermostatRunningStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readThermostatRunningStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatThermostatRunningStateCommandParams - ); - result.put("readThermostatRunningStateAttribute", readThermostatThermostatRunningStateAttributeInteractionInfo); - Map readThermostatSetpointChangeSourceCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatSetpointChangeSourceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readSetpointChangeSourceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatSetpointChangeSourceCommandParams - ); - result.put("readSetpointChangeSourceAttribute", readThermostatSetpointChangeSourceAttributeInteractionInfo); - Map readThermostatSetpointChangeAmountCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatSetpointChangeAmountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readSetpointChangeAmountAttribute( - (ChipClusters.ThermostatCluster.SetpointChangeAmountAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterSetpointChangeAmountAttributeCallback(), - readThermostatSetpointChangeAmountCommandParams - ); - result.put("readSetpointChangeAmountAttribute", readThermostatSetpointChangeAmountAttributeInteractionInfo); - Map readThermostatSetpointChangeSourceTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readSetpointChangeSourceTimestampAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatSetpointChangeSourceTimestampCommandParams - ); - result.put("readSetpointChangeSourceTimestampAttribute", readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo); - Map readThermostatOccupiedSetbackCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedSetbackAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedSetbackAttribute( - (ChipClusters.ThermostatCluster.OccupiedSetbackAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackAttributeCallback(), - readThermostatOccupiedSetbackCommandParams - ); - result.put("readOccupiedSetbackAttribute", readThermostatOccupiedSetbackAttributeInteractionInfo); - Map readThermostatOccupiedSetbackMinCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedSetbackMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedSetbackMinAttribute( - (ChipClusters.ThermostatCluster.OccupiedSetbackMinAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackMinAttributeCallback(), - readThermostatOccupiedSetbackMinCommandParams - ); - result.put("readOccupiedSetbackMinAttribute", readThermostatOccupiedSetbackMinAttributeInteractionInfo); - Map readThermostatOccupiedSetbackMaxCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedSetbackMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedSetbackMaxAttribute( - (ChipClusters.ThermostatCluster.OccupiedSetbackMaxAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackMaxAttributeCallback(), - readThermostatOccupiedSetbackMaxCommandParams - ); - result.put("readOccupiedSetbackMaxAttribute", readThermostatOccupiedSetbackMaxAttributeInteractionInfo); - Map readThermostatUnoccupiedSetbackCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedSetbackAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedSetbackAttribute( - (ChipClusters.ThermostatCluster.UnoccupiedSetbackAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterUnoccupiedSetbackAttributeCallback(), - readThermostatUnoccupiedSetbackCommandParams - ); - result.put("readUnoccupiedSetbackAttribute", readThermostatUnoccupiedSetbackAttributeInteractionInfo); - Map readThermostatUnoccupiedSetbackMinCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedSetbackMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedSetbackMinAttribute( - (ChipClusters.ThermostatCluster.UnoccupiedSetbackMinAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterUnoccupiedSetbackMinAttributeCallback(), - readThermostatUnoccupiedSetbackMinCommandParams - ); - result.put("readUnoccupiedSetbackMinAttribute", readThermostatUnoccupiedSetbackMinAttributeInteractionInfo); - Map readThermostatUnoccupiedSetbackMaxCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readUnoccupiedSetbackMaxAttribute( - (ChipClusters.ThermostatCluster.UnoccupiedSetbackMaxAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterUnoccupiedSetbackMaxAttributeCallback(), - readThermostatUnoccupiedSetbackMaxCommandParams - ); - result.put("readUnoccupiedSetbackMaxAttribute", readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo); - Map readThermostatEmergencyHeatDeltaCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatEmergencyHeatDeltaAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readEmergencyHeatDeltaAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatEmergencyHeatDeltaCommandParams - ); - result.put("readEmergencyHeatDeltaAttribute", readThermostatEmergencyHeatDeltaAttributeInteractionInfo); - Map readThermostatACTypeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACTypeCommandParams - ); - result.put("readACTypeAttribute", readThermostatACTypeAttributeInteractionInfo); - Map readThermostatACCapacityCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACCapacityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACCapacityCommandParams - ); - result.put("readACCapacityAttribute", readThermostatACCapacityAttributeInteractionInfo); - Map readThermostatACRefrigerantTypeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACRefrigerantTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACRefrigerantTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACRefrigerantTypeCommandParams - ); - result.put("readACRefrigerantTypeAttribute", readThermostatACRefrigerantTypeAttributeInteractionInfo); - Map readThermostatACCompressorTypeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACCompressorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACCompressorTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACCompressorTypeCommandParams - ); - result.put("readACCompressorTypeAttribute", readThermostatACCompressorTypeAttributeInteractionInfo); - Map readThermostatACErrorCodeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACErrorCodeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACErrorCodeAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatACErrorCodeCommandParams - ); - result.put("readACErrorCodeAttribute", readThermostatACErrorCodeAttributeInteractionInfo); - Map readThermostatACLouverPositionCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACLouverPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACLouverPositionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACLouverPositionCommandParams - ); - result.put("readACLouverPositionAttribute", readThermostatACLouverPositionAttributeInteractionInfo); - Map readThermostatACCoilTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACCoilTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACCoilTemperatureAttribute( - (ChipClusters.ThermostatCluster.ACCoilTemperatureAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterACCoilTemperatureAttributeCallback(), - readThermostatACCoilTemperatureCommandParams - ); - result.put("readACCoilTemperatureAttribute", readThermostatACCoilTemperatureAttributeInteractionInfo); - Map readThermostatACCapacityformatCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatACCapacityformatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readACCapacityformatAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatACCapacityformatCommandParams - ); - result.put("readACCapacityformatAttribute", readThermostatACCapacityformatAttributeInteractionInfo); - Map readThermostatGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ThermostatCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterGeneratedCommandListAttributeCallback(), - readThermostatGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readThermostatGeneratedCommandListAttributeInteractionInfo); - Map readThermostatAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ThermostatCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterAcceptedCommandListAttributeCallback(), - readThermostatAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readThermostatAcceptedCommandListAttributeInteractionInfo); - Map readThermostatEventListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readEventListAttribute( - (ChipClusters.ThermostatCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterEventListAttributeCallback(), - readThermostatEventListCommandParams - ); - result.put("readEventListAttribute", readThermostatEventListAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( - (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readThermostatFeatureMapAttributeInteractionInfo); - Map readThermostatClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readFanControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readFanControlFanModeCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlFanModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readFanModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlFanModeCommandParams - ); - result.put("readFanModeAttribute", readFanControlFanModeAttributeInteractionInfo); - Map readFanControlFanModeSequenceCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlFanModeSequenceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readFanModeSequenceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlFanModeSequenceCommandParams - ); - result.put("readFanModeSequenceAttribute", readFanControlFanModeSequenceAttributeInteractionInfo); - Map readFanControlPercentSettingCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlPercentSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readPercentSettingAttribute( - (ChipClusters.FanControlCluster.PercentSettingAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterPercentSettingAttributeCallback(), - readFanControlPercentSettingCommandParams - ); - result.put("readPercentSettingAttribute", readFanControlPercentSettingAttributeInteractionInfo); - Map readFanControlPercentCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlPercentCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readPercentCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlPercentCurrentCommandParams - ); - result.put("readPercentCurrentAttribute", readFanControlPercentCurrentAttributeInteractionInfo); - Map readFanControlSpeedMaxCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlSpeedMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readSpeedMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlSpeedMaxCommandParams - ); - result.put("readSpeedMaxAttribute", readFanControlSpeedMaxAttributeInteractionInfo); - Map readFanControlSpeedSettingCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlSpeedSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readSpeedSettingAttribute( - (ChipClusters.FanControlCluster.SpeedSettingAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterSpeedSettingAttributeCallback(), - readFanControlSpeedSettingCommandParams - ); - result.put("readSpeedSettingAttribute", readFanControlSpeedSettingAttributeInteractionInfo); - Map readFanControlSpeedCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlSpeedCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readSpeedCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlSpeedCurrentCommandParams - ); - result.put("readSpeedCurrentAttribute", readFanControlSpeedCurrentAttributeInteractionInfo); - Map readFanControlRockSupportCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlRockSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readRockSupportAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlRockSupportCommandParams - ); - result.put("readRockSupportAttribute", readFanControlRockSupportAttributeInteractionInfo); - Map readFanControlRockSettingCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlRockSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readRockSettingAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlRockSettingCommandParams - ); - result.put("readRockSettingAttribute", readFanControlRockSettingAttributeInteractionInfo); - Map readFanControlWindSupportCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlWindSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readWindSupportAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlWindSupportCommandParams - ); - result.put("readWindSupportAttribute", readFanControlWindSupportAttributeInteractionInfo); - Map readFanControlWindSettingCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlWindSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readWindSettingAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlWindSettingCommandParams - ); - result.put("readWindSettingAttribute", readFanControlWindSettingAttributeInteractionInfo); - Map readFanControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.FanControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterGeneratedCommandListAttributeCallback(), - readFanControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readFanControlGeneratedCommandListAttributeInteractionInfo); - Map readFanControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.FanControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterAcceptedCommandListAttributeCallback(), - readFanControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readFanControlAcceptedCommandListAttributeInteractionInfo); - Map readFanControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readEventListAttribute( - (ChipClusters.FanControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterEventListAttributeCallback(), - readFanControlEventListCommandParams - ); - result.put("readEventListAttribute", readFanControlEventListAttributeInteractionInfo); - Map readFanControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.FanControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFanControlClusterAttributeListAttributeCallback(), - readFanControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readFanControlAttributeListAttributeInteractionInfo); - Map readFanControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFanControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readFanControlFeatureMapAttributeInteractionInfo); - Map readFanControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFanControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFanControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readFanControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readThermostatUserInterfaceConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams - ); - result.put("readTemperatureDisplayModeAttribute", readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readKeypadLockoutAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams - ); - result.put("readKeypadLockoutAttribute", readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readScheduleProgrammingVisibilityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams - ); - result.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterGeneratedCommandListAttributeCallback(), - readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAcceptedCommandListAttributeCallback(), - readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readEventListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterEventListAttributeCallback(), - readThermostatUserInterfaceConfigurationEventListCommandParams - ); - result.put("readEventListAttribute", readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThermostatUserInterfaceConfigurationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readColorControlInteractionInfo() { - Map result = new LinkedHashMap<>();Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams - ); - result.put("readCurrentHueAttribute", readColorControlCurrentHueAttributeInteractionInfo); - Map readColorControlCurrentSaturationCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentSaturationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentSaturationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentSaturationCommandParams - ); - result.put("readCurrentSaturationAttribute", readColorControlCurrentSaturationAttributeInteractionInfo); - Map readColorControlRemainingTimeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlRemainingTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readRemainingTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlRemainingTimeCommandParams - ); - result.put("readRemainingTimeAttribute", readColorControlRemainingTimeAttributeInteractionInfo); - Map readColorControlCurrentXCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentXAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentXCommandParams - ); - result.put("readCurrentXAttribute", readColorControlCurrentXAttributeInteractionInfo); - Map readColorControlCurrentYCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentYAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentYCommandParams - ); - result.put("readCurrentYAttribute", readColorControlCurrentYAttributeInteractionInfo); - Map readColorControlDriftCompensationCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlDriftCompensationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readDriftCompensationAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlDriftCompensationCommandParams - ); - result.put("readDriftCompensationAttribute", readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCompensationTextAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readColorControlCompensationTextCommandParams - ); - result.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureMiredsCommandParams - ); - result.put("readColorTemperatureMiredsAttribute", readColorControlColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams - ); - result.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlOptionsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readOptionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlOptionsCommandParams - ); - result.put("readOptionsAttribute", readColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( - (ChipClusters.ColorControlCluster.NumberOfPrimariesAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterNumberOfPrimariesAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams - ); - result.put("readNumberOfPrimariesAttribute", readColorControlNumberOfPrimariesAttributeInteractionInfo); - Map readColorControlPrimary1XCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary1XAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary1XAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1XCommandParams - ); - result.put("readPrimary1XAttribute", readColorControlPrimary1XAttributeInteractionInfo); - Map readColorControlPrimary1YCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary1YAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary1YAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1YCommandParams - ); - result.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary1IntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary1IntensityAttributeCallback(), - readColorControlPrimary1IntensityCommandParams - ); - result.put("readPrimary1IntensityAttribute", readColorControlPrimary1IntensityAttributeInteractionInfo); - Map readColorControlPrimary2XCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary2XAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary2XAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2XCommandParams - ); - result.put("readPrimary2XAttribute", readColorControlPrimary2XAttributeInteractionInfo); - Map readColorControlPrimary2YCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary2YAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary2YAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2YCommandParams - ); - result.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary2IntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary2IntensityAttributeCallback(), - readColorControlPrimary2IntensityCommandParams - ); - result.put("readPrimary2IntensityAttribute", readColorControlPrimary2IntensityAttributeInteractionInfo); - Map readColorControlPrimary3XCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary3XAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary3XAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3XCommandParams - ); - result.put("readPrimary3XAttribute", readColorControlPrimary3XAttributeInteractionInfo); - Map readColorControlPrimary3YCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary3YAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary3YAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3YCommandParams - ); - result.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary3IntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary3IntensityAttributeCallback(), - readColorControlPrimary3IntensityCommandParams - ); - result.put("readPrimary3IntensityAttribute", readColorControlPrimary3IntensityAttributeInteractionInfo); - Map readColorControlPrimary4XCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary4XAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary4XAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4XCommandParams - ); - result.put("readPrimary4XAttribute", readColorControlPrimary4XAttributeInteractionInfo); - Map readColorControlPrimary4YCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary4YAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary4YAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4YCommandParams - ); - result.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary4IntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary4IntensityAttributeCallback(), - readColorControlPrimary4IntensityCommandParams - ); - result.put("readPrimary4IntensityAttribute", readColorControlPrimary4IntensityAttributeInteractionInfo); - Map readColorControlPrimary5XCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary5XAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary5XAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5XCommandParams - ); - result.put("readPrimary5XAttribute", readColorControlPrimary5XAttributeInteractionInfo); - Map readColorControlPrimary5YCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary5YAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary5YAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5YCommandParams - ); - result.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary5IntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary5IntensityAttributeCallback(), - readColorControlPrimary5IntensityCommandParams - ); - result.put("readPrimary5IntensityAttribute", readColorControlPrimary5IntensityAttributeInteractionInfo); - Map readColorControlPrimary6XCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary6XAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary6XAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6XCommandParams - ); - result.put("readPrimary6XAttribute", readColorControlPrimary6XAttributeInteractionInfo); - Map readColorControlPrimary6YCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary6YAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary6YAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6YCommandParams - ); - result.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( - (ChipClusters.ColorControlCluster.Primary6IntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterPrimary6IntensityAttributeCallback(), - readColorControlPrimary6IntensityCommandParams - ); - result.put("readPrimary6IntensityAttribute", readColorControlPrimary6IntensityAttributeInteractionInfo); - Map readColorControlWhitePointXCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlWhitePointXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readWhitePointXAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlWhitePointXCommandParams - ); - result.put("readWhitePointXAttribute", readColorControlWhitePointXAttributeInteractionInfo); - Map readColorControlWhitePointYCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlWhitePointYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readWhitePointYAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlWhitePointYCommandParams - ); - result.put("readWhitePointYAttribute", readColorControlWhitePointYAttributeInteractionInfo); - Map readColorControlColorPointRXCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointRXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointRXAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRXCommandParams - ); - result.put("readColorPointRXAttribute", readColorControlColorPointRXAttributeInteractionInfo); - Map readColorControlColorPointRYCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointRYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointRYAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRYCommandParams - ); - result.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( - (ChipClusters.ColorControlCluster.ColorPointRIntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterColorPointRIntensityAttributeCallback(), - readColorControlColorPointRIntensityCommandParams - ); - result.put("readColorPointRIntensityAttribute", readColorControlColorPointRIntensityAttributeInteractionInfo); - Map readColorControlColorPointGXCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointGXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointGXAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGXCommandParams - ); - result.put("readColorPointGXAttribute", readColorControlColorPointGXAttributeInteractionInfo); - Map readColorControlColorPointGYCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointGYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointGYAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGYCommandParams - ); - result.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( - (ChipClusters.ColorControlCluster.ColorPointGIntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterColorPointGIntensityAttributeCallback(), - readColorControlColorPointGIntensityCommandParams - ); - result.put("readColorPointGIntensityAttribute", readColorControlColorPointGIntensityAttributeInteractionInfo); - Map readColorControlColorPointBXCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointBXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointBXAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBXCommandParams - ); - result.put("readColorPointBXAttribute", readColorControlColorPointBXAttributeInteractionInfo); - Map readColorControlColorPointBYCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointBYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointBYAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBYCommandParams - ); - result.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( - (ChipClusters.ColorControlCluster.ColorPointBIntensityAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterColorPointBIntensityAttributeCallback(), - readColorControlColorPointBIntensityCommandParams - ); - result.put("readColorPointBIntensityAttribute", readColorControlColorPointBIntensityAttributeInteractionInfo); - Map readColorControlEnhancedCurrentHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlEnhancedCurrentHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readEnhancedCurrentHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlEnhancedCurrentHueCommandParams - ); - result.put("readEnhancedCurrentHueAttribute", readColorControlEnhancedCurrentHueAttributeInteractionInfo); - Map readColorControlEnhancedColorModeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlEnhancedColorModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readEnhancedColorModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlEnhancedColorModeCommandParams - ); - result.put("readEnhancedColorModeAttribute", readColorControlEnhancedColorModeAttributeInteractionInfo); - Map readColorControlColorLoopActiveCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorLoopActiveAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorLoopActiveAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopActiveCommandParams - ); - result.put("readColorLoopActiveAttribute", readColorControlColorLoopActiveAttributeInteractionInfo); - Map readColorControlColorLoopDirectionCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorLoopDirectionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorLoopDirectionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopDirectionCommandParams - ); - result.put("readColorLoopDirectionAttribute", readColorControlColorLoopDirectionAttributeInteractionInfo); - Map readColorControlColorLoopTimeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorLoopTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorLoopTimeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopTimeCommandParams - ); - result.put("readColorLoopTimeAttribute", readColorControlColorLoopTimeAttributeInteractionInfo); - Map readColorControlColorLoopStartEnhancedHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorLoopStartEnhancedHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopStartEnhancedHueCommandParams - ); - result.put("readColorLoopStartEnhancedHueAttribute", readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo); - Map readColorControlColorLoopStoredEnhancedHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorLoopStoredEnhancedHueAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorLoopStoredEnhancedHueCommandParams - ); - result.put("readColorLoopStoredEnhancedHueAttribute", readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo); - Map readColorControlColorCapabilitiesCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorCapabilitiesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorCapabilitiesAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorCapabilitiesCommandParams - ); - result.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinMiredsCommandParams - ); - result.put("readColorTempPhysicalMinMiredsAttribute", readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxMiredsCommandParams - ); - result.put("readColorTempPhysicalMaxMiredsAttribute", readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams - ); - result.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( - (ChipClusters.ColorControlCluster.StartUpColorTemperatureMiredsAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterStartUpColorTemperatureMiredsAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams - ); - result.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ColorControlCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterGeneratedCommandListAttributeCallback(), - readColorControlGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readColorControlGeneratedCommandListAttributeInteractionInfo); - Map readColorControlAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ColorControlCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterAcceptedCommandListAttributeCallback(), - readColorControlAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readColorControlAcceptedCommandListAttributeInteractionInfo); - Map readColorControlEventListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readEventListAttribute( - (ChipClusters.ColorControlCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterEventListAttributeCallback(), - readColorControlEventListCommandParams - ); - result.put("readEventListAttribute", readColorControlEventListAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( - (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readColorControlFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readColorControlFeatureMapAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readBallastConfigurationInteractionInfo() { - Map result = new LinkedHashMap<>();Map readBallastConfigurationPhysicalMinLevelCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readPhysicalMinLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationPhysicalMinLevelCommandParams - ); - result.put("readPhysicalMinLevelAttribute", readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo); - Map readBallastConfigurationPhysicalMaxLevelCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readPhysicalMaxLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationPhysicalMaxLevelCommandParams - ); - result.put("readPhysicalMaxLevelAttribute", readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo); - Map readBallastConfigurationBallastStatusCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationBallastStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readBallastStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationBallastStatusCommandParams - ); - result.put("readBallastStatusAttribute", readBallastConfigurationBallastStatusAttributeInteractionInfo); - Map readBallastConfigurationMinLevelCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationMinLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readMinLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationMinLevelCommandParams - ); - result.put("readMinLevelAttribute", readBallastConfigurationMinLevelAttributeInteractionInfo); - Map readBallastConfigurationMaxLevelCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationMaxLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readMaxLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationMaxLevelCommandParams - ); - result.put("readMaxLevelAttribute", readBallastConfigurationMaxLevelAttributeInteractionInfo); - Map readBallastConfigurationIntrinsicBallastFactorCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readIntrinsicBallastFactorAttribute( - (ChipClusters.BallastConfigurationCluster.IntrinsicBallastFactorAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterIntrinsicBallastFactorAttributeCallback(), - readBallastConfigurationIntrinsicBallastFactorCommandParams - ); - result.put("readIntrinsicBallastFactorAttribute", readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); - Map readBallastConfigurationBallastFactorAdjustmentCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readBallastFactorAdjustmentAttribute( - (ChipClusters.BallastConfigurationCluster.BallastFactorAdjustmentAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterBallastFactorAdjustmentAttributeCallback(), - readBallastConfigurationBallastFactorAdjustmentCommandParams - ); - result.put("readBallastFactorAdjustmentAttribute", readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); - Map readBallastConfigurationLampQuantityCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampQuantityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampQuantityAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationLampQuantityCommandParams - ); - result.put("readLampQuantityAttribute", readBallastConfigurationLampQuantityAttributeInteractionInfo); - Map readBallastConfigurationLampTypeCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampTypeAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBallastConfigurationLampTypeCommandParams - ); - result.put("readLampTypeAttribute", readBallastConfigurationLampTypeAttributeInteractionInfo); - Map readBallastConfigurationLampManufacturerCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampManufacturerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampManufacturerAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBallastConfigurationLampManufacturerCommandParams - ); - result.put("readLampManufacturerAttribute", readBallastConfigurationLampManufacturerAttributeInteractionInfo); - Map readBallastConfigurationLampRatedHoursCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampRatedHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampRatedHoursAttribute( - (ChipClusters.BallastConfigurationCluster.LampRatedHoursAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterLampRatedHoursAttributeCallback(), - readBallastConfigurationLampRatedHoursCommandParams - ); - result.put("readLampRatedHoursAttribute", readBallastConfigurationLampRatedHoursAttributeInteractionInfo); - Map readBallastConfigurationLampBurnHoursCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampBurnHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampBurnHoursAttribute( - (ChipClusters.BallastConfigurationCluster.LampBurnHoursAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterLampBurnHoursAttributeCallback(), - readBallastConfigurationLampBurnHoursCommandParams - ); - result.put("readLampBurnHoursAttribute", readBallastConfigurationLampBurnHoursAttributeInteractionInfo); - Map readBallastConfigurationLampAlarmModeCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampAlarmModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampAlarmModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationLampAlarmModeCommandParams - ); - result.put("readLampAlarmModeAttribute", readBallastConfigurationLampAlarmModeAttributeInteractionInfo); - Map readBallastConfigurationLampBurnHoursTripPointCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readLampBurnHoursTripPointAttribute( - (ChipClusters.BallastConfigurationCluster.LampBurnHoursTripPointAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterLampBurnHoursTripPointAttributeCallback(), - readBallastConfigurationLampBurnHoursTripPointCommandParams - ); - result.put("readLampBurnHoursTripPointAttribute", readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); - Map readBallastConfigurationGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.BallastConfigurationCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterGeneratedCommandListAttributeCallback(), - readBallastConfigurationGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readBallastConfigurationGeneratedCommandListAttributeInteractionInfo); - Map readBallastConfigurationAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.BallastConfigurationCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterAcceptedCommandListAttributeCallback(), - readBallastConfigurationAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readBallastConfigurationAcceptedCommandListAttributeInteractionInfo); - Map readBallastConfigurationEventListCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readEventListAttribute( - (ChipClusters.BallastConfigurationCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterEventListAttributeCallback(), - readBallastConfigurationEventListCommandParams - ); - result.put("readEventListAttribute", readBallastConfigurationEventListAttributeInteractionInfo); - Map readBallastConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readAttributeListAttribute( - (ChipClusters.BallastConfigurationCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBallastConfigurationClusterAttributeListAttributeCallback(), - readBallastConfigurationAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readBallastConfigurationAttributeListAttributeInteractionInfo); - Map readBallastConfigurationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBallastConfigurationFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readBallastConfigurationFeatureMapAttributeInteractionInfo); - Map readBallastConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBallastConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBallastConfigurationClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readBallastConfigurationClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readIlluminanceMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterMeasuredValueAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams - ); - result.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterMinMeasuredValueAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams - ); - result.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterMaxMeasuredValueAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams - ); - result.put("readMaxMeasuredValueAttribute", readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementToleranceCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readToleranceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementToleranceCommandParams - ); - result.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( - (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterLightSensorTypeAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams - ); - result.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterGeneratedCommandListAttributeCallback(), - readIlluminanceMeasurementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readIlluminanceMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAcceptedCommandListAttributeCallback(), - readIlluminanceMeasurementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readIlluminanceMeasurementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readEventListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterEventListAttributeCallback(), - readIlluminanceMeasurementEventListCommandParams - ); - result.put("readEventListAttribute", readIlluminanceMeasurementEventListAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readIlluminanceMeasurementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readIlluminanceMeasurementFeatureMapAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readTemperatureMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( - (ChipClusters.TemperatureMeasurementCluster.MeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterMeasuredValueAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams - ); - result.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - (ChipClusters.TemperatureMeasurementCluster.MinMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterMinMeasuredValueAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams - ); - result.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - (ChipClusters.TemperatureMeasurementCluster.MaxMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterMaxMeasuredValueAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams - ); - result.put("readMaxMeasuredValueAttribute", readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementToleranceCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readToleranceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementToleranceCommandParams - ); - result.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.TemperatureMeasurementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterGeneratedCommandListAttributeCallback(), - readTemperatureMeasurementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readTemperatureMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.TemperatureMeasurementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAcceptedCommandListAttributeCallback(), - readTemperatureMeasurementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readTemperatureMeasurementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readEventListAttribute( - (ChipClusters.TemperatureMeasurementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterEventListAttributeCallback(), - readTemperatureMeasurementEventListCommandParams - ); - result.put("readEventListAttribute", readTemperatureMeasurementEventListAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( - (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTemperatureMeasurementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readTemperatureMeasurementFeatureMapAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readPressureMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( - (ChipClusters.PressureMeasurementCluster.MeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMeasuredValueAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams - ); - result.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - (ChipClusters.PressureMeasurementCluster.MinMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMinMeasuredValueAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams - ); - result.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - (ChipClusters.PressureMeasurementCluster.MaxMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMaxMeasuredValueAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams - ); - result.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementToleranceCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readToleranceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementToleranceCommandParams - ); - result.put("readToleranceAttribute", readPressureMeasurementToleranceAttributeInteractionInfo); - Map readPressureMeasurementScaledValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementScaledValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readScaledValueAttribute( - (ChipClusters.PressureMeasurementCluster.ScaledValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterScaledValueAttributeCallback(), - readPressureMeasurementScaledValueCommandParams - ); - result.put("readScaledValueAttribute", readPressureMeasurementScaledValueAttributeInteractionInfo); - Map readPressureMeasurementMinScaledValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinScaledValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMinScaledValueAttribute( - (ChipClusters.PressureMeasurementCluster.MinScaledValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMinScaledValueAttributeCallback(), - readPressureMeasurementMinScaledValueCommandParams - ); - result.put("readMinScaledValueAttribute", readPressureMeasurementMinScaledValueAttributeInteractionInfo); - Map readPressureMeasurementMaxScaledValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxScaledValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMaxScaledValueAttribute( - (ChipClusters.PressureMeasurementCluster.MaxScaledValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterMaxScaledValueAttributeCallback(), - readPressureMeasurementMaxScaledValueCommandParams - ); - result.put("readMaxScaledValueAttribute", readPressureMeasurementMaxScaledValueAttributeInteractionInfo); - Map readPressureMeasurementScaledToleranceCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementScaledToleranceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readScaledToleranceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementScaledToleranceCommandParams - ); - result.put("readScaledToleranceAttribute", readPressureMeasurementScaledToleranceAttributeInteractionInfo); - Map readPressureMeasurementScaleCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementScaleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readScaleAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementScaleCommandParams - ); - result.put("readScaleAttribute", readPressureMeasurementScaleAttributeInteractionInfo); - Map readPressureMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.PressureMeasurementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterGeneratedCommandListAttributeCallback(), - readPressureMeasurementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readPressureMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readPressureMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.PressureMeasurementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAcceptedCommandListAttributeCallback(), - readPressureMeasurementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readPressureMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readPressureMeasurementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readEventListAttribute( - (ChipClusters.PressureMeasurementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterEventListAttributeCallback(), - readPressureMeasurementEventListCommandParams - ); - result.put("readEventListAttribute", readPressureMeasurementEventListAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( - (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPressureMeasurementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readPressureMeasurementFeatureMapAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readFlowMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( - (ChipClusters.FlowMeasurementCluster.MeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterMeasuredValueAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams - ); - result.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( - (ChipClusters.FlowMeasurementCluster.MinMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterMinMeasuredValueAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams - ); - result.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - (ChipClusters.FlowMeasurementCluster.MaxMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterMaxMeasuredValueAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams - ); - result.put("readMaxMeasuredValueAttribute", readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementToleranceCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readToleranceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementToleranceCommandParams - ); - result.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.FlowMeasurementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterGeneratedCommandListAttributeCallback(), - readFlowMeasurementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readFlowMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readFlowMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.FlowMeasurementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAcceptedCommandListAttributeCallback(), - readFlowMeasurementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readFlowMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readFlowMeasurementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readEventListAttribute( - (ChipClusters.FlowMeasurementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterEventListAttributeCallback(), - readFlowMeasurementEventListCommandParams - ); - result.put("readEventListAttribute", readFlowMeasurementEventListAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( - (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFlowMeasurementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readFlowMeasurementFeatureMapAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readRelativeHumidityMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.MeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterMeasuredValueAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams - ); - result.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.MinMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterMinMeasuredValueAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams - ); - result.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.MaxMeasuredValueAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterMaxMeasuredValueAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams - ); - result.put("readMaxMeasuredValueAttribute", readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementToleranceCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementToleranceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readToleranceAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementToleranceCommandParams - ); - result.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map readRelativeHumidityMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterGeneratedCommandListAttributeCallback(), - readRelativeHumidityMeasurementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAcceptedCommandListAttributeCallback(), - readRelativeHumidityMeasurementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readEventListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterEventListAttributeCallback(), - readRelativeHumidityMeasurementEventListCommandParams - ); - result.put("readEventListAttribute", readRelativeHumidityMeasurementEventListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readRelativeHumidityMeasurementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readOccupancySensingInteractionInfo() { - Map result = new LinkedHashMap<>();Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams - ); - result.put("readOccupancyAttribute", readOccupancySensingOccupancyAttributeInteractionInfo); - Map readOccupancySensingOccupancySensorTypeCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancySensorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readOccupancySensorTypeAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancySensorTypeCommandParams - ); - result.put("readOccupancySensorTypeAttribute", readOccupancySensingOccupancySensorTypeAttributeInteractionInfo); - Map readOccupancySensingOccupancySensorTypeBitmapCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readOccupancySensorTypeBitmapAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancySensorTypeBitmapCommandParams - ); - result.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readPIROccupiedToUnoccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams - ); - result.put("readPIROccupiedToUnoccupiedDelayAttribute", readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readPIRUnoccupiedToOccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams - ); - result.put("readPIRUnoccupiedToOccupiedDelayAttribute", readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readPIRUnoccupiedToOccupiedThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams - ); - result.put("readPIRUnoccupiedToOccupiedThresholdAttribute", readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readUltrasonicOccupiedToUnoccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams - ); - result.put("readUltrasonicOccupiedToUnoccupiedDelayAttribute", readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readUltrasonicUnoccupiedToOccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams - ); - result.put("readUltrasonicUnoccupiedToOccupiedDelayAttribute", readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readUltrasonicUnoccupiedToOccupiedThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams - ); - result.put("readUltrasonicUnoccupiedToOccupiedThresholdAttribute", readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readPhysicalContactOccupiedToUnoccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams - ); - result.put("readPhysicalContactOccupiedToUnoccupiedDelayAttribute", readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readPhysicalContactUnoccupiedToOccupiedDelayAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams - ); - result.put("readPhysicalContactUnoccupiedToOccupiedDelayAttribute", readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readPhysicalContactUnoccupiedToOccupiedThresholdAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams - ); - result.put("readPhysicalContactUnoccupiedToOccupiedThresholdAttribute", readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map readOccupancySensingGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.OccupancySensingCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterGeneratedCommandListAttributeCallback(), - readOccupancySensingGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readOccupancySensingGeneratedCommandListAttributeInteractionInfo); - Map readOccupancySensingAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.OccupancySensingCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAcceptedCommandListAttributeCallback(), - readOccupancySensingAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readOccupancySensingAcceptedCommandListAttributeInteractionInfo); - Map readOccupancySensingEventListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readEventListAttribute( - (ChipClusters.OccupancySensingCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterEventListAttributeCallback(), - readOccupancySensingEventListCommandParams - ); - result.put("readEventListAttribute", readOccupancySensingEventListAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( - (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readOccupancySensingFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readOccupancySensingFeatureMapAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readWakeOnLanInteractionInfo() { - Map result = new LinkedHashMap<>();Map readWakeOnLanMACAddressCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanMACAddressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readMACAddressAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanMACAddressCommandParams - ); - result.put("readMACAddressAttribute", readWakeOnLanMACAddressAttributeInteractionInfo); - Map readWakeOnLanGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.WakeOnLanCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterGeneratedCommandListAttributeCallback(), - readWakeOnLanGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readWakeOnLanGeneratedCommandListAttributeInteractionInfo); - Map readWakeOnLanAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.WakeOnLanCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAcceptedCommandListAttributeCallback(), - readWakeOnLanAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readWakeOnLanAcceptedCommandListAttributeInteractionInfo); - Map readWakeOnLanEventListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readEventListAttribute( - (ChipClusters.WakeOnLanCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterEventListAttributeCallback(), - readWakeOnLanEventListCommandParams - ); - result.put("readEventListAttribute", readWakeOnLanEventListAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( - (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWakeOnLanFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readWakeOnLanFeatureMapAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readChannelInteractionInfo() { - Map result = new LinkedHashMap<>();Map readChannelChannelListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readChannelListAttribute( - (ChipClusters.ChannelCluster.ChannelListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterChannelListAttributeCallback(), - readChannelChannelListCommandParams - ); - result.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ChannelCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterGeneratedCommandListAttributeCallback(), - readChannelGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readChannelGeneratedCommandListAttributeInteractionInfo); - Map readChannelAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ChannelCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterAcceptedCommandListAttributeCallback(), - readChannelAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readChannelAcceptedCommandListAttributeInteractionInfo); - Map readChannelEventListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readEventListAttribute( - (ChipClusters.ChannelCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterEventListAttributeCallback(), - readChannelEventListCommandParams - ); - result.put("readEventListAttribute", readChannelEventListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( - (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readChannelFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readChannelFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readChannelFeatureMapAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readTargetNavigatorInteractionInfo() { - Map result = new LinkedHashMap<>();Map readTargetNavigatorTargetListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readTargetListAttribute( - (ChipClusters.TargetNavigatorCluster.TargetListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetListAttributeCallback(), - readTargetNavigatorTargetListCommandParams - ); - result.put("readTargetListAttribute", readTargetNavigatorTargetListAttributeInteractionInfo); - Map readTargetNavigatorCurrentTargetCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentTargetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentTargetAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentTargetCommandParams - ); - result.put("readCurrentTargetAttribute", readTargetNavigatorCurrentTargetAttributeInteractionInfo); - Map readTargetNavigatorGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.TargetNavigatorCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterGeneratedCommandListAttributeCallback(), - readTargetNavigatorGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readTargetNavigatorGeneratedCommandListAttributeInteractionInfo); - Map readTargetNavigatorAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.TargetNavigatorCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAcceptedCommandListAttributeCallback(), - readTargetNavigatorAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readTargetNavigatorAcceptedCommandListAttributeInteractionInfo); - Map readTargetNavigatorEventListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readEventListAttribute( - (ChipClusters.TargetNavigatorCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterEventListAttributeCallback(), - readTargetNavigatorEventListCommandParams - ); - result.put("readEventListAttribute", readTargetNavigatorEventListAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( - (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTargetNavigatorFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readTargetNavigatorFeatureMapAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readMediaPlaybackInteractionInfo() { - Map result = new LinkedHashMap<>();Map readMediaPlaybackCurrentStateCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackCurrentStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readCurrentStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackCurrentStateCommandParams - ); - result.put("readCurrentStateAttribute", readMediaPlaybackCurrentStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( - (ChipClusters.MediaPlaybackCluster.StartTimeAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterStartTimeAttributeCallback(), - readMediaPlaybackStartTimeCommandParams - ); - result.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( - (ChipClusters.MediaPlaybackCluster.DurationAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterDurationAttributeCallback(), - readMediaPlaybackDurationCommandParams - ); - result.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackSpeedAttribute( - (ChipClusters.FloatAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readMediaPlaybackPlaybackSpeedCommandParams - ); - result.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( - (ChipClusters.MediaPlaybackCluster.SeekRangeEndAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterSeekRangeEndAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams - ); - result.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( - (ChipClusters.MediaPlaybackCluster.SeekRangeStartAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterSeekRangeStartAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams - ); - result.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.MediaPlaybackCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterGeneratedCommandListAttributeCallback(), - readMediaPlaybackGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readMediaPlaybackGeneratedCommandListAttributeInteractionInfo); - Map readMediaPlaybackAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.MediaPlaybackCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAcceptedCommandListAttributeCallback(), - readMediaPlaybackAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readMediaPlaybackAcceptedCommandListAttributeInteractionInfo); - Map readMediaPlaybackEventListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readEventListAttribute( - (ChipClusters.MediaPlaybackCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterEventListAttributeCallback(), - readMediaPlaybackEventListCommandParams - ); - result.put("readEventListAttribute", readMediaPlaybackEventListAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( - (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readMediaPlaybackFeatureMapAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readMediaInputInteractionInfo() { - Map result = new LinkedHashMap<>();Map readMediaInputInputListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputInputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readInputListAttribute( - (ChipClusters.MediaInputCluster.InputListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterInputListAttributeCallback(), - readMediaInputInputListCommandParams - ); - result.put("readInputListAttribute", readMediaInputInputListAttributeInteractionInfo); - Map readMediaInputCurrentInputCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputCurrentInputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readCurrentInputAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentInputCommandParams - ); - result.put("readCurrentInputAttribute", readMediaInputCurrentInputAttributeInteractionInfo); - Map readMediaInputGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.MediaInputCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterGeneratedCommandListAttributeCallback(), - readMediaInputGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readMediaInputGeneratedCommandListAttributeInteractionInfo); - Map readMediaInputAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.MediaInputCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterAcceptedCommandListAttributeCallback(), - readMediaInputAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readMediaInputAcceptedCommandListAttributeInteractionInfo); - Map readMediaInputEventListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readEventListAttribute( - (ChipClusters.MediaInputCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterEventListAttributeCallback(), - readMediaInputEventListCommandParams - ); - result.put("readEventListAttribute", readMediaInputEventListAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( - (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaInputFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readMediaInputFeatureMapAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readLowPowerInteractionInfo() { - Map result = new LinkedHashMap<>();Map readLowPowerGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.LowPowerCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLowPowerClusterGeneratedCommandListAttributeCallback(), - readLowPowerGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readLowPowerGeneratedCommandListAttributeInteractionInfo); - Map readLowPowerAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.LowPowerCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLowPowerClusterAcceptedCommandListAttributeCallback(), - readLowPowerAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readLowPowerAcceptedCommandListAttributeInteractionInfo); - Map readLowPowerEventListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readEventListAttribute( - (ChipClusters.LowPowerCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLowPowerClusterEventListAttributeCallback(), - readLowPowerEventListCommandParams - ); - result.put("readEventListAttribute", readLowPowerEventListAttributeInteractionInfo); - Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( - (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readLowPowerFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readLowPowerFeatureMapAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readKeypadInputInteractionInfo() { - Map result = new LinkedHashMap<>();Map readKeypadInputGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.KeypadInputCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterGeneratedCommandListAttributeCallback(), - readKeypadInputGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readKeypadInputGeneratedCommandListAttributeInteractionInfo); - Map readKeypadInputAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.KeypadInputCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAcceptedCommandListAttributeCallback(), - readKeypadInputAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readKeypadInputAcceptedCommandListAttributeInteractionInfo); - Map readKeypadInputEventListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readEventListAttribute( - (ChipClusters.KeypadInputCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterEventListAttributeCallback(), - readKeypadInputEventListCommandParams - ); - result.put("readEventListAttribute", readKeypadInputEventListAttributeInteractionInfo); - Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( - (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readKeypadInputFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readKeypadInputFeatureMapAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readContentLauncherInteractionInfo() { - Map result = new LinkedHashMap<>();Map readContentLauncherAcceptHeaderCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderAttribute( - (ChipClusters.ContentLauncherCluster.AcceptHeaderAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderAttributeCallback(), - readContentLauncherAcceptHeaderCommandParams - ); - result.put("readAcceptHeaderAttribute", readContentLauncherAcceptHeaderAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams - ); - result.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ContentLauncherCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterGeneratedCommandListAttributeCallback(), - readContentLauncherGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readContentLauncherGeneratedCommandListAttributeInteractionInfo); - Map readContentLauncherAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ContentLauncherCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptedCommandListAttributeCallback(), - readContentLauncherAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readContentLauncherAcceptedCommandListAttributeInteractionInfo); - Map readContentLauncherEventListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readEventListAttribute( - (ChipClusters.ContentLauncherCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterEventListAttributeCallback(), - readContentLauncherEventListCommandParams - ); - result.put("readEventListAttribute", readContentLauncherEventListAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( - (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readContentLauncherFeatureMapAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readAudioOutputInteractionInfo() { - Map result = new LinkedHashMap<>();Map readAudioOutputOutputListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputOutputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readOutputListAttribute( - (ChipClusters.AudioOutputCluster.OutputListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterOutputListAttributeCallback(), - readAudioOutputOutputListCommandParams - ); - result.put("readOutputListAttribute", readAudioOutputOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentOutputCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentOutputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readCurrentOutputAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentOutputCommandParams - ); - result.put("readCurrentOutputAttribute", readAudioOutputCurrentOutputAttributeInteractionInfo); - Map readAudioOutputGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.AudioOutputCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterGeneratedCommandListAttributeCallback(), - readAudioOutputGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readAudioOutputGeneratedCommandListAttributeInteractionInfo); - Map readAudioOutputAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.AudioOutputCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAcceptedCommandListAttributeCallback(), - readAudioOutputAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readAudioOutputAcceptedCommandListAttributeInteractionInfo); - Map readAudioOutputEventListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readEventListAttribute( - (ChipClusters.AudioOutputCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterEventListAttributeCallback(), - readAudioOutputEventListCommandParams - ); - result.put("readEventListAttribute", readAudioOutputEventListAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( - (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAudioOutputFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readAudioOutputFeatureMapAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readApplicationLauncherInteractionInfo() { - Map result = new LinkedHashMap<>();Map readApplicationLauncherCatalogListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherCatalogListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readCatalogListAttribute( - (ChipClusters.ApplicationLauncherCluster.CatalogListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterCatalogListAttributeCallback(), - readApplicationLauncherCatalogListCommandParams - ); - result.put("readCatalogListAttribute", readApplicationLauncherCatalogListAttributeInteractionInfo); - Map readApplicationLauncherGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ApplicationLauncherCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterGeneratedCommandListAttributeCallback(), - readApplicationLauncherGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readApplicationLauncherGeneratedCommandListAttributeInteractionInfo); - Map readApplicationLauncherAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ApplicationLauncherCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAcceptedCommandListAttributeCallback(), - readApplicationLauncherAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readApplicationLauncherAcceptedCommandListAttributeInteractionInfo); - Map readApplicationLauncherEventListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readEventListAttribute( - (ChipClusters.ApplicationLauncherCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterEventListAttributeCallback(), - readApplicationLauncherEventListCommandParams - ); - result.put("readEventListAttribute", readApplicationLauncherEventListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( - (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readApplicationLauncherFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readApplicationLauncherFeatureMapAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readApplicationBasicInteractionInfo() { - Map result = new LinkedHashMap<>();Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams - ); - result.put("readVendorNameAttribute", readApplicationBasicVendorNameAttributeInteractionInfo); - Map readApplicationBasicVendorIDCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readVendorIDAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicVendorIDCommandParams - ); - result.put("readVendorIDAttribute", readApplicationBasicVendorIDAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationNameCommandParams - ); - result.put("readApplicationNameAttribute", readApplicationBasicApplicationNameAttributeInteractionInfo); - Map readApplicationBasicProductIDCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicProductIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readProductIDAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicProductIDCommandParams - ); - result.put("readProductIDAttribute", readApplicationBasicProductIDAttributeInteractionInfo); - Map readApplicationBasicStatusCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicStatusCommandParams - ); - result.put("readStatusAttribute", readApplicationBasicStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams - ); - result.put("readApplicationVersionAttribute", readApplicationBasicApplicationVersionAttributeInteractionInfo); - Map readApplicationBasicAllowedVendorListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicAllowedVendorListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readAllowedVendorListAttribute( - (ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback(), - readApplicationBasicAllowedVendorListCommandParams - ); - result.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ApplicationBasicCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterGeneratedCommandListAttributeCallback(), - readApplicationBasicGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readApplicationBasicGeneratedCommandListAttributeInteractionInfo); - Map readApplicationBasicAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ApplicationBasicCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAcceptedCommandListAttributeCallback(), - readApplicationBasicAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readApplicationBasicAcceptedCommandListAttributeInteractionInfo); - Map readApplicationBasicEventListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readEventListAttribute( - (ChipClusters.ApplicationBasicCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterEventListAttributeCallback(), - readApplicationBasicEventListCommandParams - ); - result.put("readEventListAttribute", readApplicationBasicEventListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( - (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readApplicationBasicFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readApplicationBasicFeatureMapAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readAccountLoginInteractionInfo() { - Map result = new LinkedHashMap<>();Map readAccountLoginGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.AccountLoginCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterGeneratedCommandListAttributeCallback(), - readAccountLoginGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readAccountLoginGeneratedCommandListAttributeInteractionInfo); - Map readAccountLoginAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.AccountLoginCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAcceptedCommandListAttributeCallback(), - readAccountLoginAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readAccountLoginAcceptedCommandListAttributeInteractionInfo); - Map readAccountLoginEventListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readEventListAttribute( - (ChipClusters.AccountLoginCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterEventListAttributeCallback(), - readAccountLoginEventListCommandParams - ); - result.put("readEventListAttribute", readAccountLoginEventListAttributeInteractionInfo); - Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( - (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readAccountLoginFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readAccountLoginFeatureMapAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readElectricalMeasurementInteractionInfo() { - Map result = new LinkedHashMap<>();Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams - ); - result.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageCommandParams - ); - result.put("readDcVoltageAttribute", readElectricalMeasurementDcVoltageAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageMinCommandParams - ); - result.put("readDcVoltageMinAttribute", readElectricalMeasurementDcVoltageMinAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageMaxCommandParams - ); - result.put("readDcVoltageMaxAttribute", readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentCommandParams - ); - result.put("readDcCurrentAttribute", readElectricalMeasurementDcCurrentAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentMinCommandParams - ); - result.put("readDcCurrentMinAttribute", readElectricalMeasurementDcCurrentMinAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentMaxCommandParams - ); - result.put("readDcCurrentMaxAttribute", readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerCommandParams - ); - result.put("readDcPowerAttribute", readElectricalMeasurementDcPowerAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerMinCommandParams - ); - result.put("readDcPowerMinAttribute", readElectricalMeasurementDcPowerMinAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerMaxCommandParams - ); - result.put("readDcPowerMaxAttribute", readElectricalMeasurementDcPowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageMultiplierCommandParams - ); - result.put("readDcVoltageMultiplierAttribute", readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementDcVoltageDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcVoltageDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcVoltageDivisorCommandParams - ); - result.put("readDcVoltageDivisorAttribute", readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentMultiplierCommandParams - ); - result.put("readDcCurrentMultiplierAttribute", readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementDcCurrentDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcCurrentDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcCurrentDivisorCommandParams - ); - result.put("readDcCurrentDivisorAttribute", readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerMultiplierCommandParams - ); - result.put("readDcPowerMultiplierAttribute", readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementDcPowerDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readDcPowerDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementDcPowerDivisorCommandParams - ); - result.put("readDcPowerDivisorAttribute", readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyCommandParams - ); - result.put("readAcFrequencyAttribute", readElectricalMeasurementAcFrequencyAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyMinCommandParams - ); - result.put("readAcFrequencyMinAttribute", readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyMaxCommandParams - ); - result.put("readAcFrequencyMaxAttribute", readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo); - Map readElectricalMeasurementNeutralCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementNeutralCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readNeutralCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementNeutralCurrentCommandParams - ); - result.put("readNeutralCurrentAttribute", readElectricalMeasurementNeutralCurrentAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams - ); - result.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementTotalReactivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalReactivePowerAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalReactivePowerCommandParams - ); - result.put("readTotalReactivePowerAttribute", readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo); - Map readElectricalMeasurementTotalApparentPowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalApparentPowerAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalApparentPowerCommandParams - ); - result.put("readTotalApparentPowerAttribute", readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo); - Map readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured1stHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams - ); - result.put("readMeasured1stHarmonicCurrentAttribute", readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured3rdHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams - ); - result.put("readMeasured3rdHarmonicCurrentAttribute", readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured5thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams - ); - result.put("readMeasured5thHarmonicCurrentAttribute", readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured7thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams - ); - result.put("readMeasured7thHarmonicCurrentAttribute", readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured9thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams - ); - result.put("readMeasured9thHarmonicCurrentAttribute", readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasured11thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams - ); - result.put("readMeasured11thHarmonicCurrentAttribute", readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase1stHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams - ); - result.put("readMeasuredPhase1stHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase3rdHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams - ); - result.put("readMeasuredPhase3rdHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase5thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams - ); - result.put("readMeasuredPhase5thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase7thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams - ); - result.put("readMeasuredPhase7thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase9thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams - ); - result.put("readMeasuredPhase9thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasuredPhase11thHarmonicCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams - ); - result.put("readMeasuredPhase11thHarmonicCurrentAttribute", readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyMultiplierCommandParams - ); - result.put("readAcFrequencyMultiplierAttribute", readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcFrequencyDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcFrequencyDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcFrequencyDivisorCommandParams - ); - result.put("readAcFrequencyDivisorAttribute", readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo); - Map readElectricalMeasurementPowerMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerMultiplierAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementPowerMultiplierCommandParams - ); - result.put("readPowerMultiplierAttribute", readElectricalMeasurementPowerMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementPowerDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerDivisorAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementPowerDivisorCommandParams - ); - result.put("readPowerDivisorAttribute", readElectricalMeasurementPowerDivisorAttributeInteractionInfo); - Map readElectricalMeasurementHarmonicCurrentMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readHarmonicCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementHarmonicCurrentMultiplierCommandParams - ); - result.put("readHarmonicCurrentMultiplierAttribute", readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readPhaseHarmonicCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams - ); - result.put("readPhaseHarmonicCurrentMultiplierAttribute", readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousVoltageCommandParams - ); - result.put("readInstantaneousVoltageAttribute", readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousLineCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousLineCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousLineCurrentCommandParams - ); - result.put("readInstantaneousLineCurrentAttribute", readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousActiveCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousActiveCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousActiveCurrentCommandParams - ); - result.put("readInstantaneousActiveCurrentAttribute", readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousReactiveCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousReactiveCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousReactiveCurrentCommandParams - ); - result.put("readInstantaneousReactiveCurrentAttribute", readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo); - Map readElectricalMeasurementInstantaneousPowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readInstantaneousPowerAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementInstantaneousPowerCommandParams - ); - result.put("readInstantaneousPowerAttribute", readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams - ); - result.put("readRmsVoltageAttribute", readElectricalMeasurementRmsVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMinCommandParams - ); - result.put("readRmsVoltageMinAttribute", readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMaxCommandParams - ); - result.put("readRmsVoltageMaxAttribute", readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentCommandParams - ); - result.put("readRmsCurrentAttribute", readElectricalMeasurementRmsCurrentAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMinCommandParams - ); - result.put("readRmsCurrentMinAttribute", readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMaxCommandParams - ); - result.put("readRmsCurrentMaxAttribute", readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerCommandParams - ); - result.put("readActivePowerAttribute", readElectricalMeasurementActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMinCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMinCommandParams - ); - result.put("readActivePowerMinAttribute", readElectricalMeasurementActivePowerMinAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMaxCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMaxCommandParams - ); - result.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementReactivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactivePowerAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactivePowerCommandParams - ); - result.put("readReactivePowerAttribute", readElectricalMeasurementReactivePowerAttributeInteractionInfo); - Map readElectricalMeasurementApparentPowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementApparentPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readApparentPowerAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementApparentPowerCommandParams - ); - result.put("readApparentPowerAttribute", readElectricalMeasurementApparentPowerAttributeInteractionInfo); - Map readElectricalMeasurementPowerFactorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerFactorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerFactorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPowerFactorCommandParams - ); - result.put("readPowerFactorAttribute", readElectricalMeasurementPowerFactorAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsVoltageMeasurementPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams - ); - result.put("readAverageRmsVoltageMeasurementPeriodAttribute", readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageCounterAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams - ); - result.put("readAverageRmsUnderVoltageCounterAttribute", readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltagePeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams - ); - result.put("readRmsExtremeOverVoltagePeriodAttribute", readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltagePeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams - ); - result.put("readRmsExtremeUnderVoltagePeriodAttribute", readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSagPeriodCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagPeriodCommandParams - ); - result.put("readRmsVoltageSagPeriodAttribute", readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSwellPeriodCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellPeriodAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellPeriodCommandParams - ); - result.put("readRmsVoltageSwellPeriodAttribute", readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); - Map readElectricalMeasurementAcVoltageMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcVoltageMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcVoltageMultiplierCommandParams - ); - result.put("readAcVoltageMultiplierAttribute", readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcVoltageDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcVoltageDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcVoltageDivisorCommandParams - ); - result.put("readAcVoltageDivisorAttribute", readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo); - Map readElectricalMeasurementAcCurrentMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcCurrentMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcCurrentMultiplierCommandParams - ); - result.put("readAcCurrentMultiplierAttribute", readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcCurrentDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcCurrentDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcCurrentDivisorCommandParams - ); - result.put("readAcCurrentDivisorAttribute", readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo); - Map readElectricalMeasurementAcPowerMultiplierCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcPowerMultiplierAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcPowerMultiplierCommandParams - ); - result.put("readAcPowerMultiplierAttribute", readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo); - Map readElectricalMeasurementAcPowerDivisorCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcPowerDivisorAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcPowerDivisorCommandParams - ); - result.put("readAcPowerDivisorAttribute", readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo); - Map readElectricalMeasurementOverloadAlarmsMaskCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readOverloadAlarmsMaskAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementOverloadAlarmsMaskCommandParams - ); - result.put("readOverloadAlarmsMaskAttribute", readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); - Map readElectricalMeasurementVoltageOverloadCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementVoltageOverloadAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readVoltageOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementVoltageOverloadCommandParams - ); - result.put("readVoltageOverloadAttribute", readElectricalMeasurementVoltageOverloadAttributeInteractionInfo); - Map readElectricalMeasurementCurrentOverloadCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementCurrentOverloadAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readCurrentOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementCurrentOverloadCommandParams - ); - result.put("readCurrentOverloadAttribute", readElectricalMeasurementCurrentOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcOverloadAlarmsMaskCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcOverloadAlarmsMaskAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcOverloadAlarmsMaskCommandParams - ); - result.put("readAcOverloadAlarmsMaskAttribute", readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); - Map readElectricalMeasurementAcVoltageOverloadCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcVoltageOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcVoltageOverloadCommandParams - ); - result.put("readAcVoltageOverloadAttribute", readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcCurrentOverloadCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcCurrentOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcCurrentOverloadCommandParams - ); - result.put("readAcCurrentOverloadAttribute", readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcActivePowerOverloadCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcActivePowerOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcActivePowerOverloadCommandParams - ); - result.put("readAcActivePowerOverloadAttribute", readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAcReactivePowerOverloadCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcReactivePowerOverloadAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAcReactivePowerOverloadCommandParams - ); - result.put("readAcReactivePowerOverloadAttribute", readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsOverVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsOverVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsOverVoltageCommandParams - ); - result.put("readAverageRmsOverVoltageAttribute", readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsUnderVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCommandParams - ); - result.put("readAverageRmsUnderVoltageAttribute", readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeOverVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltageCommandParams - ); - result.put("readRmsExtremeOverVoltageAttribute", readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeUnderVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltageAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltageCommandParams - ); - result.put("readRmsExtremeUnderVoltageAttribute", readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSagCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagCommandParams - ); - result.put("readRmsVoltageSagAttribute", readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSwellCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellCommandParams - ); - result.put("readRmsVoltageSwellAttribute", readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo); - Map readElectricalMeasurementLineCurrentPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readLineCurrentPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementLineCurrentPhaseBCommandParams - ); - result.put("readLineCurrentPhaseBAttribute", readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActiveCurrentPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActiveCurrentPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActiveCurrentPhaseBCommandParams - ); - result.put("readActiveCurrentPhaseBAttribute", readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementReactiveCurrentPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactiveCurrentPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactiveCurrentPhaseBCommandParams - ); - result.put("readReactiveCurrentPhaseBAttribute", readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltagePhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltagePhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltagePhaseBCommandParams - ); - result.put("readRmsVoltagePhaseBAttribute", readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMinPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMinPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMinPhaseBCommandParams - ); - result.put("readRmsVoltageMinPhaseBAttribute", readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMaxPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams - ); - result.put("readRmsVoltageMaxPhaseBAttribute", readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentPhaseBCommandParams - ); - result.put("readRmsCurrentPhaseBAttribute", readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMinPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMinPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMinPhaseBCommandParams - ); - result.put("readRmsCurrentMinPhaseBAttribute", readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMaxPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams - ); - result.put("readRmsCurrentMaxPhaseBAttribute", readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerPhaseBCommandParams - ); - result.put("readActivePowerPhaseBAttribute", readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMinPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMinPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMinPhaseBCommandParams - ); - result.put("readActivePowerMinPhaseBAttribute", readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMaxPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMaxPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMaxPhaseBCommandParams - ); - result.put("readActivePowerMaxPhaseBAttribute", readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementReactivePowerPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactivePowerPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactivePowerPhaseBCommandParams - ); - result.put("readReactivePowerPhaseBAttribute", readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementApparentPowerPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readApparentPowerPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementApparentPowerPhaseBCommandParams - ); - result.put("readApparentPowerPhaseBAttribute", readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementPowerFactorPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerFactorPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPowerFactorPhaseBCommandParams - ); - result.put("readPowerFactorPhaseBAttribute", readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsVoltageMeasurementPeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams - ); - result.put("readAverageRmsVoltageMeasurementPeriodPhaseBAttribute", readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsOverVoltageCounterPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams - ); - result.put("readAverageRmsOverVoltageCounterPhaseBAttribute", readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageCounterPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams - ); - result.put("readAverageRmsUnderVoltageCounterPhaseBAttribute", readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltagePeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams - ); - result.put("readRmsExtremeOverVoltagePeriodPhaseBAttribute", readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltagePeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams - ); - result.put("readRmsExtremeUnderVoltagePeriodPhaseBAttribute", readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagPeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams - ); - result.put("readRmsVoltageSagPeriodPhaseBAttribute", readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellPeriodPhaseBAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams - ); - result.put("readRmsVoltageSwellPeriodPhaseBAttribute", readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo); - Map readElectricalMeasurementLineCurrentPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readLineCurrentPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementLineCurrentPhaseCCommandParams - ); - result.put("readLineCurrentPhaseCAttribute", readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActiveCurrentPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActiveCurrentPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActiveCurrentPhaseCCommandParams - ); - result.put("readActiveCurrentPhaseCAttribute", readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementReactiveCurrentPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactiveCurrentPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactiveCurrentPhaseCCommandParams - ); - result.put("readReactiveCurrentPhaseCAttribute", readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltagePhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltagePhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltagePhaseCCommandParams - ); - result.put("readRmsVoltagePhaseCAttribute", readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMinPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMinPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMinPhaseCCommandParams - ); - result.put("readRmsVoltageMinPhaseCAttribute", readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageMaxPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams - ); - result.put("readRmsVoltageMaxPhaseCAttribute", readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentPhaseCCommandParams - ); - result.put("readRmsCurrentPhaseCAttribute", readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMinPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMinPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMinPhaseCCommandParams - ); - result.put("readRmsCurrentMinPhaseCAttribute", readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsCurrentMaxPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams - ); - result.put("readRmsCurrentMaxPhaseCAttribute", readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerPhaseCCommandParams - ); - result.put("readActivePowerPhaseCAttribute", readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMinPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMinPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMinPhaseCCommandParams - ); - result.put("readActivePowerMinPhaseCAttribute", readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementActivePowerMaxPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readActivePowerMaxPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementActivePowerMaxPhaseCCommandParams - ); - result.put("readActivePowerMaxPhaseCAttribute", readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementReactivePowerPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readReactivePowerPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementReactivePowerPhaseCCommandParams - ); - result.put("readReactivePowerPhaseCAttribute", readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementApparentPowerPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readApparentPowerPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementApparentPowerPhaseCCommandParams - ); - result.put("readApparentPowerPhaseCAttribute", readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementPowerFactorPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readPowerFactorPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementPowerFactorPhaseCCommandParams - ); - result.put("readPowerFactorPhaseCAttribute", readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsVoltageMeasurementPeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams - ); - result.put("readAverageRmsVoltageMeasurementPeriodPhaseCAttribute", readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsOverVoltageCounterPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams - ); - result.put("readAverageRmsOverVoltageCounterPhaseCAttribute", readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAverageRmsUnderVoltageCounterPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams - ); - result.put("readAverageRmsUnderVoltageCounterPhaseCAttribute", readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeOverVoltagePeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams - ); - result.put("readRmsExtremeOverVoltagePeriodPhaseCAttribute", readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsExtremeUnderVoltagePeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams - ); - result.put("readRmsExtremeUnderVoltagePeriodPhaseCAttribute", readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSagPeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams - ); - result.put("readRmsVoltageSagPeriodPhaseCAttribute", readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageSwellPeriodPhaseCAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams - ); - result.put("readRmsVoltageSwellPeriodPhaseCAttribute", readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo); - Map readElectricalMeasurementGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.ElectricalMeasurementCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterGeneratedCommandListAttributeCallback(), - readElectricalMeasurementGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo); - Map readElectricalMeasurementAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.ElectricalMeasurementCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAcceptedCommandListAttributeCallback(), - readElectricalMeasurementAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo); - Map readElectricalMeasurementEventListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readEventListAttribute( - (ChipClusters.ElectricalMeasurementCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterEventListAttributeCallback(), - readElectricalMeasurementEventListCommandParams - ); - result.put("readEventListAttribute", readElectricalMeasurementEventListAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( - (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readElectricalMeasurementFeatureMapAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readUnitTestingInteractionInfo() { - Map result = new LinkedHashMap<>();Map readUnitTestingBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingBooleanCommandParams - ); - result.put("readBooleanAttribute", readUnitTestingBooleanAttributeInteractionInfo); - Map readUnitTestingBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readBitmap8Attribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingBitmap8CommandParams - ); - result.put("readBitmap8Attribute", readUnitTestingBitmap8AttributeInteractionInfo); - Map readUnitTestingBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readBitmap16Attribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingBitmap16CommandParams - ); - result.put("readBitmap16Attribute", readUnitTestingBitmap16AttributeInteractionInfo); - Map readUnitTestingBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readBitmap32Attribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingBitmap32CommandParams - ); - result.put("readBitmap32Attribute", readUnitTestingBitmap32AttributeInteractionInfo); - Map readUnitTestingBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readBitmap64Attribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingBitmap64CommandParams - ); - result.put("readBitmap64Attribute", readUnitTestingBitmap64AttributeInteractionInfo); - Map readUnitTestingInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt8uAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt8uCommandParams - ); - result.put("readInt8uAttribute", readUnitTestingInt8uAttributeInteractionInfo); - Map readUnitTestingInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt16uAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt16uCommandParams - ); - result.put("readInt16uAttribute", readUnitTestingInt16uAttributeInteractionInfo); - Map readUnitTestingInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt24uAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt24uCommandParams - ); - result.put("readInt24uAttribute", readUnitTestingInt24uAttributeInteractionInfo); - Map readUnitTestingInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt32uAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt32uCommandParams - ); - result.put("readInt32uAttribute", readUnitTestingInt32uAttributeInteractionInfo); - Map readUnitTestingInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt40uAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt40uCommandParams - ); - result.put("readInt40uAttribute", readUnitTestingInt40uAttributeInteractionInfo); - Map readUnitTestingInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt48uAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt48uCommandParams - ); - result.put("readInt48uAttribute", readUnitTestingInt48uAttributeInteractionInfo); - Map readUnitTestingInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt56uAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt56uCommandParams - ); - result.put("readInt56uAttribute", readUnitTestingInt56uAttributeInteractionInfo); - Map readUnitTestingInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt64uAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt64uCommandParams - ); - result.put("readInt64uAttribute", readUnitTestingInt64uAttributeInteractionInfo); - Map readUnitTestingInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt8sAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt8sCommandParams - ); - result.put("readInt8sAttribute", readUnitTestingInt8sAttributeInteractionInfo); - Map readUnitTestingInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt16sAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingInt16sCommandParams - ); - result.put("readInt16sAttribute", readUnitTestingInt16sAttributeInteractionInfo); - Map readUnitTestingInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt24sAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt24sCommandParams - ); - result.put("readInt24sAttribute", readUnitTestingInt24sAttributeInteractionInfo); - Map readUnitTestingInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt32sAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt32sCommandParams - ); - result.put("readInt32sAttribute", readUnitTestingInt32sAttributeInteractionInfo); - Map readUnitTestingInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt40sAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt40sCommandParams - ); - result.put("readInt40sAttribute", readUnitTestingInt40sAttributeInteractionInfo); - Map readUnitTestingInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt48sAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt48sCommandParams - ); - result.put("readInt48sAttribute", readUnitTestingInt48sAttributeInteractionInfo); - Map readUnitTestingInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt56sAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt56sCommandParams - ); - result.put("readInt56sAttribute", readUnitTestingInt56sAttributeInteractionInfo); - Map readUnitTestingInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readInt64sAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingInt64sCommandParams - ); - result.put("readInt64sAttribute", readUnitTestingInt64sAttributeInteractionInfo); - Map readUnitTestingEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readEnum8Attribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingEnum8CommandParams - ); - result.put("readEnum8Attribute", readUnitTestingEnum8AttributeInteractionInfo); - Map readUnitTestingEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readEnum16Attribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingEnum16CommandParams - ); - result.put("readEnum16Attribute", readUnitTestingEnum16AttributeInteractionInfo); - Map readUnitTestingFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readFloatSingleAttribute( - (ChipClusters.FloatAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readUnitTestingFloatSingleCommandParams - ); - result.put("readFloatSingleAttribute", readUnitTestingFloatSingleAttributeInteractionInfo); - Map readUnitTestingFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readFloatDoubleAttribute( - (ChipClusters.DoubleAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readUnitTestingFloatDoubleCommandParams - ); - result.put("readFloatDoubleAttribute", readUnitTestingFloatDoubleAttributeInteractionInfo); - Map readUnitTestingOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readOctetStringAttribute( - (ChipClusters.OctetStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readUnitTestingOctetStringCommandParams - ); - result.put("readOctetStringAttribute", readUnitTestingOctetStringAttributeInteractionInfo); - Map readUnitTestingListInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingListInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readListInt8uAttribute( - (ChipClusters.UnitTestingCluster.ListInt8uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListInt8uAttributeCallback(), - readUnitTestingListInt8uCommandParams - ); - result.put("readListInt8uAttribute", readUnitTestingListInt8uAttributeInteractionInfo); - Map readUnitTestingListOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingListOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readListOctetStringAttribute( - (ChipClusters.UnitTestingCluster.ListOctetStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListOctetStringAttributeCallback(), - readUnitTestingListOctetStringCommandParams - ); - result.put("readListOctetStringAttribute", readUnitTestingListOctetStringAttributeInteractionInfo); - Map readUnitTestingListStructOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingListStructOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readListStructOctetStringAttribute( - (ChipClusters.UnitTestingCluster.ListStructOctetStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListStructOctetStringAttributeCallback(), - readUnitTestingListStructOctetStringCommandParams - ); - result.put("readListStructOctetStringAttribute", readUnitTestingListStructOctetStringAttributeInteractionInfo); - Map readUnitTestingLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readLongOctetStringAttribute( - (ChipClusters.OctetStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readUnitTestingLongOctetStringCommandParams - ); - result.put("readLongOctetStringAttribute", readUnitTestingLongOctetStringAttributeInteractionInfo); - Map readUnitTestingCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readCharStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readUnitTestingCharStringCommandParams - ); - result.put("readCharStringAttribute", readUnitTestingCharStringAttributeInteractionInfo); - Map readUnitTestingLongCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readLongCharStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readUnitTestingLongCharStringCommandParams - ); - result.put("readLongCharStringAttribute", readUnitTestingLongCharStringAttributeInteractionInfo); - Map readUnitTestingEpochUsCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readEpochUsAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingEpochUsCommandParams - ); - result.put("readEpochUsAttribute", readUnitTestingEpochUsAttributeInteractionInfo); - Map readUnitTestingEpochSCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readEpochSAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingEpochSCommandParams - ); - result.put("readEpochSAttribute", readUnitTestingEpochSAttributeInteractionInfo); - Map readUnitTestingVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readVendorIdAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingVendorIdCommandParams - ); - result.put("readVendorIdAttribute", readUnitTestingVendorIdAttributeInteractionInfo); - Map readUnitTestingListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readListNullablesAndOptionalsStructAttribute( - (ChipClusters.UnitTestingCluster.ListNullablesAndOptionalsStructAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListNullablesAndOptionalsStructAttributeCallback(), - readUnitTestingListNullablesAndOptionalsStructCommandParams - ); - result.put("readListNullablesAndOptionalsStructAttribute", readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readUnitTestingEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readEnumAttrAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingEnumAttrCommandParams - ); - result.put("readEnumAttrAttribute", readUnitTestingEnumAttrAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt8uAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt8uCommandParams - ); - result.put("readRangeRestrictedInt8uAttribute", readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt8sAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt8sCommandParams - ); - result.put("readRangeRestrictedInt8sAttribute", readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt16uAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt16uCommandParams - ); - result.put("readRangeRestrictedInt16uAttribute", readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); - Map readUnitTestingRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readRangeRestrictedInt16sAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingRangeRestrictedInt16sCommandParams - ); - result.put("readRangeRestrictedInt16sAttribute", readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); - Map readUnitTestingListLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingListLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readListLongOctetStringAttribute( - (ChipClusters.UnitTestingCluster.ListLongOctetStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListLongOctetStringAttributeCallback(), - readUnitTestingListLongOctetStringCommandParams - ); - result.put("readListLongOctetStringAttribute", readUnitTestingListLongOctetStringAttributeInteractionInfo); - Map readUnitTestingListFabricScopedCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingListFabricScopedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readListFabricScopedAttribute( - (ChipClusters.UnitTestingCluster.ListFabricScopedAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListFabricScopedAttributeCallback(), - readUnitTestingListFabricScopedCommandParams - ); - result.put("readListFabricScopedAttribute", readUnitTestingListFabricScopedAttributeInteractionInfo); - Map readUnitTestingTimedWriteBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readTimedWriteBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingTimedWriteBooleanCommandParams - ); - result.put("readTimedWriteBooleanAttribute", readUnitTestingTimedWriteBooleanAttributeInteractionInfo); - Map readUnitTestingGeneralErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readGeneralErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingGeneralErrorBooleanCommandParams - ); - result.put("readGeneralErrorBooleanAttribute", readUnitTestingGeneralErrorBooleanAttributeInteractionInfo); - Map readUnitTestingClusterErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readClusterErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingClusterErrorBooleanCommandParams - ); - result.put("readClusterErrorBooleanAttribute", readUnitTestingClusterErrorBooleanAttributeInteractionInfo); - Map readUnitTestingUnsupportedCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readUnsupportedAttribute( - (ChipClusters.BooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readUnitTestingUnsupportedCommandParams - ); - result.put("readUnsupportedAttribute", readUnitTestingUnsupportedAttributeInteractionInfo); - Map readUnitTestingNullableBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableBooleanAttribute( - (ChipClusters.UnitTestingCluster.NullableBooleanAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBooleanAttributeCallback(), - readUnitTestingNullableBooleanCommandParams - ); - result.put("readNullableBooleanAttribute", readUnitTestingNullableBooleanAttributeInteractionInfo); - Map readUnitTestingNullableBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap8Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap8AttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap8AttributeCallback(), - readUnitTestingNullableBitmap8CommandParams - ); - result.put("readNullableBitmap8Attribute", readUnitTestingNullableBitmap8AttributeInteractionInfo); - Map readUnitTestingNullableBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap16Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap16AttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap16AttributeCallback(), - readUnitTestingNullableBitmap16CommandParams - ); - result.put("readNullableBitmap16Attribute", readUnitTestingNullableBitmap16AttributeInteractionInfo); - Map readUnitTestingNullableBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap32Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap32AttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap32AttributeCallback(), - readUnitTestingNullableBitmap32CommandParams - ); - result.put("readNullableBitmap32Attribute", readUnitTestingNullableBitmap32AttributeInteractionInfo); - Map readUnitTestingNullableBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableBitmap64Attribute( - (ChipClusters.UnitTestingCluster.NullableBitmap64AttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableBitmap64AttributeCallback(), - readUnitTestingNullableBitmap64CommandParams - ); - result.put("readNullableBitmap64Attribute", readUnitTestingNullableBitmap64AttributeInteractionInfo); - Map readUnitTestingNullableInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt8uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt8uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8uAttributeCallback(), - readUnitTestingNullableInt8uCommandParams - ); - result.put("readNullableInt8uAttribute", readUnitTestingNullableInt8uAttributeInteractionInfo); - Map readUnitTestingNullableInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt16uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt16uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16uAttributeCallback(), - readUnitTestingNullableInt16uCommandParams - ); - result.put("readNullableInt16uAttribute", readUnitTestingNullableInt16uAttributeInteractionInfo); - Map readUnitTestingNullableInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt24uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt24uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24uAttributeCallback(), - readUnitTestingNullableInt24uCommandParams - ); - result.put("readNullableInt24uAttribute", readUnitTestingNullableInt24uAttributeInteractionInfo); - Map readUnitTestingNullableInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt32uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt32uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32uAttributeCallback(), - readUnitTestingNullableInt32uCommandParams - ); - result.put("readNullableInt32uAttribute", readUnitTestingNullableInt32uAttributeInteractionInfo); - Map readUnitTestingNullableInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt40uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt40uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40uAttributeCallback(), - readUnitTestingNullableInt40uCommandParams - ); - result.put("readNullableInt40uAttribute", readUnitTestingNullableInt40uAttributeInteractionInfo); - Map readUnitTestingNullableInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt48uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt48uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48uAttributeCallback(), - readUnitTestingNullableInt48uCommandParams - ); - result.put("readNullableInt48uAttribute", readUnitTestingNullableInt48uAttributeInteractionInfo); - Map readUnitTestingNullableInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt56uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt56uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56uAttributeCallback(), - readUnitTestingNullableInt56uCommandParams - ); - result.put("readNullableInt56uAttribute", readUnitTestingNullableInt56uAttributeInteractionInfo); - Map readUnitTestingNullableInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt64uAttribute( - (ChipClusters.UnitTestingCluster.NullableInt64uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64uAttributeCallback(), - readUnitTestingNullableInt64uCommandParams - ); - result.put("readNullableInt64uAttribute", readUnitTestingNullableInt64uAttributeInteractionInfo); - Map readUnitTestingNullableInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt8sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt8sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8sAttributeCallback(), - readUnitTestingNullableInt8sCommandParams - ); - result.put("readNullableInt8sAttribute", readUnitTestingNullableInt8sAttributeInteractionInfo); - Map readUnitTestingNullableInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt16sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt16sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16sAttributeCallback(), - readUnitTestingNullableInt16sCommandParams - ); - result.put("readNullableInt16sAttribute", readUnitTestingNullableInt16sAttributeInteractionInfo); - Map readUnitTestingNullableInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt24sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt24sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24sAttributeCallback(), - readUnitTestingNullableInt24sCommandParams - ); - result.put("readNullableInt24sAttribute", readUnitTestingNullableInt24sAttributeInteractionInfo); - Map readUnitTestingNullableInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt32sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt32sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32sAttributeCallback(), - readUnitTestingNullableInt32sCommandParams - ); - result.put("readNullableInt32sAttribute", readUnitTestingNullableInt32sAttributeInteractionInfo); - Map readUnitTestingNullableInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt40sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt40sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40sAttributeCallback(), - readUnitTestingNullableInt40sCommandParams - ); - result.put("readNullableInt40sAttribute", readUnitTestingNullableInt40sAttributeInteractionInfo); - Map readUnitTestingNullableInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt48sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt48sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48sAttributeCallback(), - readUnitTestingNullableInt48sCommandParams - ); - result.put("readNullableInt48sAttribute", readUnitTestingNullableInt48sAttributeInteractionInfo); - Map readUnitTestingNullableInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt56sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt56sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56sAttributeCallback(), - readUnitTestingNullableInt56sCommandParams - ); - result.put("readNullableInt56sAttribute", readUnitTestingNullableInt56sAttributeInteractionInfo); - Map readUnitTestingNullableInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableInt64sAttribute( - (ChipClusters.UnitTestingCluster.NullableInt64sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64sAttributeCallback(), - readUnitTestingNullableInt64sCommandParams - ); - result.put("readNullableInt64sAttribute", readUnitTestingNullableInt64sAttributeInteractionInfo); - Map readUnitTestingNullableEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableEnum8Attribute( - (ChipClusters.UnitTestingCluster.NullableEnum8AttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum8AttributeCallback(), - readUnitTestingNullableEnum8CommandParams - ); - result.put("readNullableEnum8Attribute", readUnitTestingNullableEnum8AttributeInteractionInfo); - Map readUnitTestingNullableEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableEnum16Attribute( - (ChipClusters.UnitTestingCluster.NullableEnum16AttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum16AttributeCallback(), - readUnitTestingNullableEnum16CommandParams - ); - result.put("readNullableEnum16Attribute", readUnitTestingNullableEnum16AttributeInteractionInfo); - Map readUnitTestingNullableFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableFloatSingleAttribute( - (ChipClusters.UnitTestingCluster.NullableFloatSingleAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableFloatSingleAttributeCallback(), - readUnitTestingNullableFloatSingleCommandParams - ); - result.put("readNullableFloatSingleAttribute", readUnitTestingNullableFloatSingleAttributeInteractionInfo); - Map readUnitTestingNullableFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableFloatDoubleAttribute( - (ChipClusters.UnitTestingCluster.NullableFloatDoubleAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableFloatDoubleAttributeCallback(), - readUnitTestingNullableFloatDoubleCommandParams - ); - result.put("readNullableFloatDoubleAttribute", readUnitTestingNullableFloatDoubleAttributeInteractionInfo); - Map readUnitTestingNullableOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableOctetStringAttribute( - (ChipClusters.UnitTestingCluster.NullableOctetStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableOctetStringAttributeCallback(), - readUnitTestingNullableOctetStringCommandParams - ); - result.put("readNullableOctetStringAttribute", readUnitTestingNullableOctetStringAttributeInteractionInfo); - Map readUnitTestingNullableCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableCharStringAttribute( - (ChipClusters.UnitTestingCluster.NullableCharStringAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableCharStringAttributeCallback(), - readUnitTestingNullableCharStringCommandParams - ); - result.put("readNullableCharStringAttribute", readUnitTestingNullableCharStringAttributeInteractionInfo); - Map readUnitTestingNullableEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableEnumAttrAttribute( - (ChipClusters.UnitTestingCluster.NullableEnumAttrAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnumAttrAttributeCallback(), - readUnitTestingNullableEnumAttrCommandParams - ); - result.put("readNullableEnumAttrAttribute", readUnitTestingNullableEnumAttrAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt8uAttribute( - (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt8uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt8uAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt8uCommandParams - ); - result.put("readNullableRangeRestrictedInt8uAttribute", readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt8sAttribute( - (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt8sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt8sAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt8sCommandParams - ); - result.put("readNullableRangeRestrictedInt8sAttribute", readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt16uAttribute( - (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt16uAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt16uAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt16uCommandParams - ); - result.put("readNullableRangeRestrictedInt16uAttribute", readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readUnitTestingNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readNullableRangeRestrictedInt16sAttribute( - (ChipClusters.UnitTestingCluster.NullableRangeRestrictedInt16sAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterNullableRangeRestrictedInt16sAttributeCallback(), - readUnitTestingNullableRangeRestrictedInt16sCommandParams - ); - result.put("readNullableRangeRestrictedInt16sAttribute", readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readUnitTestingWriteOnlyInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingWriteOnlyInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readWriteOnlyInt8uAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingWriteOnlyInt8uCommandParams - ); - result.put("readWriteOnlyInt8uAttribute", readUnitTestingWriteOnlyInt8uAttributeInteractionInfo); - Map readUnitTestingGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.UnitTestingCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterGeneratedCommandListAttributeCallback(), - readUnitTestingGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readUnitTestingGeneratedCommandListAttributeInteractionInfo); - Map readUnitTestingAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.UnitTestingCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterAcceptedCommandListAttributeCallback(), - readUnitTestingAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readUnitTestingAcceptedCommandListAttributeInteractionInfo); - Map readUnitTestingEventListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readEventListAttribute( - (ChipClusters.UnitTestingCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterEventListAttributeCallback(), - readUnitTestingEventListCommandParams - ); - result.put("readEventListAttribute", readUnitTestingEventListAttributeInteractionInfo); - Map readUnitTestingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readAttributeListAttribute( - (ChipClusters.UnitTestingCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedUnitTestingClusterAttributeListAttributeCallback(), - readUnitTestingAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readUnitTestingAttributeListAttributeInteractionInfo); - Map readUnitTestingFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitTestingFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readUnitTestingFeatureMapAttributeInteractionInfo); - Map readUnitTestingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUnitTestingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitTestingClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readUnitTestingClusterRevisionAttributeInteractionInfo); - - return result; - } - private static Map readFaultInjectionInteractionInfo() { - Map result = new LinkedHashMap<>();Map readFaultInjectionGeneratedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFaultInjectionGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster).readGeneratedCommandListAttribute( - (ChipClusters.FaultInjectionCluster.GeneratedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterGeneratedCommandListAttributeCallback(), - readFaultInjectionGeneratedCommandListCommandParams - ); - result.put("readGeneratedCommandListAttribute", readFaultInjectionGeneratedCommandListAttributeInteractionInfo); - Map readFaultInjectionAcceptedCommandListCommandParams = new LinkedHashMap(); - InteractionInfo readFaultInjectionAcceptedCommandListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster).readAcceptedCommandListAttribute( - (ChipClusters.FaultInjectionCluster.AcceptedCommandListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterAcceptedCommandListAttributeCallback(), - readFaultInjectionAcceptedCommandListCommandParams - ); - result.put("readAcceptedCommandListAttribute", readFaultInjectionAcceptedCommandListAttributeInteractionInfo); - Map readFaultInjectionEventListCommandParams = new LinkedHashMap(); - InteractionInfo readFaultInjectionEventListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster).readEventListAttribute( - (ChipClusters.FaultInjectionCluster.EventListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterEventListAttributeCallback(), - readFaultInjectionEventListCommandParams - ); - result.put("readEventListAttribute", readFaultInjectionEventListAttributeInteractionInfo); - Map readFaultInjectionAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFaultInjectionAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster).readAttributeListAttribute( - (ChipClusters.FaultInjectionCluster.AttributeListAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterAttributeListAttributeCallback(), - readFaultInjectionAttributeListCommandParams - ); - result.put("readAttributeListAttribute", readFaultInjectionAttributeListAttributeInteractionInfo); - Map readFaultInjectionFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readFaultInjectionFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster).readFeatureMapAttribute( - (ChipClusters.LongAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readFaultInjectionFeatureMapCommandParams - ); - result.put("readFeatureMapAttribute", readFaultInjectionFeatureMapAttributeInteractionInfo); - Map readFaultInjectionClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFaultInjectionClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FaultInjectionCluster) cluster).readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFaultInjectionClusterRevisionCommandParams - ); - result.put("readClusterRevisionAttribute", readFaultInjectionClusterRevisionAttributeInteractionInfo); - - return result; - } - @SuppressWarnings("serial") - public Map> getReadAttributeMap() { - - return new HashMap>(){{ - put("identify", readIdentifyInteractionInfo()); - put("groups", readGroupsInteractionInfo()); - put("scenes", readScenesInteractionInfo()); - put("onOff", readOnOffInteractionInfo()); - put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo()); - put("levelControl", readLevelControlInteractionInfo()); - put("binaryInputBasic", readBinaryInputBasicInteractionInfo()); - put("pulseWidthModulation", readPulseWidthModulationInteractionInfo()); - put("descriptor", readDescriptorInteractionInfo()); - put("binding", readBindingInteractionInfo()); - put("accessControl", readAccessControlInteractionInfo()); - put("actions", readActionsInteractionInfo()); - put("basicInformation", readBasicInformationInteractionInfo()); - put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo()); - put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo()); - put("localizationConfiguration", readLocalizationConfigurationInteractionInfo()); - put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo()); - put("unitLocalization", readUnitLocalizationInteractionInfo()); - put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo()); - put("powerSource", readPowerSourceInteractionInfo()); - put("generalCommissioning", readGeneralCommissioningInteractionInfo()); - put("networkCommissioning", readNetworkCommissioningInteractionInfo()); - put("diagnosticLogs", readDiagnosticLogsInteractionInfo()); - put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo()); - put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo()); - put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo()); - put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo()); - put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo()); - put("timeSynchronization", readTimeSynchronizationInteractionInfo()); - put("bridgedDeviceBasicInformation", readBridgedDeviceBasicInformationInteractionInfo()); - put("switch", readSwitchInteractionInfo()); - put("administratorCommissioning", readAdministratorCommissioningInteractionInfo()); - put("operationalCredentials", readOperationalCredentialsInteractionInfo()); - put("groupKeyManagement", readGroupKeyManagementInteractionInfo()); - put("fixedLabel", readFixedLabelInteractionInfo()); - put("userLabel", readUserLabelInteractionInfo()); - put("proxyConfiguration", readProxyConfigurationInteractionInfo()); - put("proxyDiscovery", readProxyDiscoveryInteractionInfo()); - put("proxyValid", readProxyValidInteractionInfo()); - put("booleanState", readBooleanStateInteractionInfo()); - put("icdManagement", readIcdManagementInteractionInfo()); - put("modeSelect", readModeSelectInteractionInfo()); - put("temperatureControl", readTemperatureControlInteractionInfo()); - put("refrigeratorAlarm", readRefrigeratorAlarmInteractionInfo()); - put("airQuality", readAirQualityInteractionInfo()); - put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo()); - put("dishwasherAlarm", readDishwasherAlarmInteractionInfo()); - put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo()); - put("activatedCarbonFilterMonitoring", readActivatedCarbonFilterMonitoringInteractionInfo()); - put("ceramicFilterMonitoring", readCeramicFilterMonitoringInteractionInfo()); - put("electrostaticFilterMonitoring", readElectrostaticFilterMonitoringInteractionInfo()); - put("uvFilterMonitoring", readUvFilterMonitoringInteractionInfo()); - put("ionizingFilterMonitoring", readIonizingFilterMonitoringInteractionInfo()); - put("zeoliteFilterMonitoring", readZeoliteFilterMonitoringInteractionInfo()); - put("ozoneFilterMonitoring", readOzoneFilterMonitoringInteractionInfo()); - put("waterTankMonitoring", readWaterTankMonitoringInteractionInfo()); - put("fuelTankMonitoring", readFuelTankMonitoringInteractionInfo()); - put("inkCartridgeMonitoring", readInkCartridgeMonitoringInteractionInfo()); - put("tonerCartridgeMonitoring", readTonerCartridgeMonitoringInteractionInfo()); - put("doorLock", readDoorLockInteractionInfo()); - put("windowCovering", readWindowCoveringInteractionInfo()); - put("barrierControl", readBarrierControlInteractionInfo()); - put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo()); - put("thermostat", readThermostatInteractionInfo()); - put("fanControl", readFanControlInteractionInfo()); - put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo()); - put("colorControl", readColorControlInteractionInfo()); - put("ballastConfiguration", readBallastConfigurationInteractionInfo()); - put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo()); - put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo()); - put("pressureMeasurement", readPressureMeasurementInteractionInfo()); - put("flowMeasurement", readFlowMeasurementInteractionInfo()); - put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo()); - put("occupancySensing", readOccupancySensingInteractionInfo()); - put("wakeOnLan", readWakeOnLanInteractionInfo()); - put("channel", readChannelInteractionInfo()); - put("targetNavigator", readTargetNavigatorInteractionInfo()); - put("mediaPlayback", readMediaPlaybackInteractionInfo()); - put("mediaInput", readMediaInputInteractionInfo()); - put("lowPower", readLowPowerInteractionInfo()); - put("keypadInput", readKeypadInputInteractionInfo()); - put("contentLauncher", readContentLauncherInteractionInfo()); - put("audioOutput", readAudioOutputInteractionInfo()); - put("applicationLauncher", readApplicationLauncherInteractionInfo()); - put("applicationBasic", readApplicationBasicInteractionInfo()); - put("accountLogin", readAccountLoginInteractionInfo()); - put("electricalMeasurement", readElectricalMeasurementInteractionInfo()); - put("unitTesting", readUnitTestingInteractionInfo()); - put("faultInjection", readFaultInjectionInteractionInfo());}}; - } -} + return result; + } + + private static Map readGroupsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readGroupsNameSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams); + result.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.GroupsCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupsClusterGeneratedCommandListAttributeCallback(), + readGroupsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readGroupsGeneratedCommandListAttributeInteractionInfo); + Map readGroupsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.GroupsCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedGroupsClusterAcceptedCommandListAttributeCallback(), + readGroupsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readGroupsAcceptedCommandListAttributeInteractionInfo); + Map readGroupsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readEventListAttribute( + (ChipClusters.GroupsCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedGroupsClusterEventListAttributeCallback(), + readGroupsEventListCommandParams); + result.put("readEventListAttribute", readGroupsEventListAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), + readGroupsAttributeListCommandParams); + result.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGroupsFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readGroupsFeatureMapAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readScenesInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readScenesSceneCountCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams); + result.put("readSceneCountAttribute", readScenesSceneCountAttributeInteractionInfo); + Map readScenesCurrentSceneCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesCurrentSceneAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readCurrentSceneAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesCurrentSceneCommandParams); + result.put("readCurrentSceneAttribute", readScenesCurrentSceneAttributeInteractionInfo); + Map readScenesCurrentGroupCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesCurrentGroupAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readCurrentGroupAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesCurrentGroupCommandParams); + result.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); + Map readScenesSceneValidCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesSceneValidAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readSceneValidAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readScenesSceneValidCommandParams); + result.put("readSceneValidAttribute", readScenesSceneValidAttributeInteractionInfo); + Map readScenesNameSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesNameSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesNameSupportCommandParams); + result.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesLastConfiguredByCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesLastConfiguredByAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readLastConfiguredByAttribute( + (ChipClusters.ScenesCluster.LastConfiguredByAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterLastConfiguredByAttributeCallback(), + readScenesLastConfiguredByCommandParams); + result.put("readLastConfiguredByAttribute", readScenesLastConfiguredByAttributeInteractionInfo); + Map readScenesGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ScenesCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedScenesClusterGeneratedCommandListAttributeCallback(), + readScenesGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readScenesGeneratedCommandListAttributeInteractionInfo); + Map readScenesAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ScenesCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedScenesClusterAcceptedCommandListAttributeCallback(), + readScenesAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readScenesAcceptedCommandListAttributeInteractionInfo); + Map readScenesEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readEventListAttribute( + (ChipClusters.ScenesCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterEventListAttributeCallback(), + readScenesEventListCommandParams); + result.put("readEventListAttribute", readScenesEventListAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), + readScenesAttributeListCommandParams); + result.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readScenesFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readScenesFeatureMapAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOnOffInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readOnOffOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOnOffOnOffCommandParams); + result.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); + Map readOnOffGlobalSceneControlCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readGlobalSceneControlAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOnOffGlobalSceneControlCommandParams); + result.put( + "readGlobalSceneControlAttribute", readOnOffGlobalSceneControlAttributeInteractionInfo); + Map readOnOffOnTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffOnTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readOnTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffOnTimeCommandParams); + result.put("readOnTimeAttribute", readOnOffOnTimeAttributeInteractionInfo); + Map readOnOffOffWaitTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffOffWaitTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readOffWaitTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffOffWaitTimeCommandParams); + result.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readStartUpOnOffAttribute( + (ChipClusters.OnOffCluster.StartUpOnOffAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterStartUpOnOffAttributeCallback(), + readOnOffStartUpOnOffCommandParams); + result.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OnOffCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedOnOffClusterGeneratedCommandListAttributeCallback(), + readOnOffGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", readOnOffGeneratedCommandListAttributeInteractionInfo); + Map readOnOffAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OnOffCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedOnOffClusterAcceptedCommandListAttributeCallback(), + readOnOffAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readOnOffAcceptedCommandListAttributeInteractionInfo); + Map readOnOffEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readEventListAttribute( + (ChipClusters.OnOffCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterEventListAttributeCallback(), + readOnOffEventListCommandParams); + result.put("readEventListAttribute", readOnOffEventListAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), + readOnOffAttributeListCommandParams); + result.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); + Map readOnOffFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOnOffFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readOnOffFeatureMapAttributeInteractionInfo); + Map readOnOffClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOnOffSwitchConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readOnOffSwitchConfigurationSwitchTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams); + result.put( + "readSwitchTypeAttribute", readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo); + Map readOnOffSwitchConfigurationSwitchActionsCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readSwitchActionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchActionsCommandParams); + result.put( + "readSwitchActionsAttribute", + readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map + readOnOffSwitchConfigurationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterGeneratedCommandListAttributeCallback(), + readOnOffSwitchConfigurationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readOnOffSwitchConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterAcceptedCommandListAttributeCallback(), + readOnOffSwitchConfigurationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readOnOffSwitchConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readEventListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterEventListAttributeCallback(), + readOnOffSwitchConfigurationEventListCommandParams); + result.put( + "readEventListAttribute", readOnOffSwitchConfigurationEventListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOnOffSwitchConfigurationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readOnOffSwitchConfigurationFeatureMapAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readLevelControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readLevelControlCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.CurrentLevelAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedLevelControlClusterCurrentLevelAttributeCallback(), + readLevelControlCurrentLevelCommandParams); + result.put("readCurrentLevelAttribute", readLevelControlCurrentLevelAttributeInteractionInfo); + Map readLevelControlRemainingTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlRemainingTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readRemainingTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlRemainingTimeCommandParams); + result.put("readRemainingTimeAttribute", readLevelControlRemainingTimeAttributeInteractionInfo); + Map readLevelControlMinLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlMinLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMinLevelCommandParams); + result.put("readMinLevelAttribute", readLevelControlMinLevelAttributeInteractionInfo); + Map readLevelControlMaxLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlMaxLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMaxLevelCommandParams); + result.put("readMaxLevelAttribute", readLevelControlMaxLevelAttributeInteractionInfo); + Map readLevelControlCurrentFrequencyCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlCurrentFrequencyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readCurrentFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentFrequencyCommandParams); + result.put( + "readCurrentFrequencyAttribute", readLevelControlCurrentFrequencyAttributeInteractionInfo); + Map readLevelControlMinFrequencyCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlMinFrequencyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readMinFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMinFrequencyCommandParams); + result.put("readMinFrequencyAttribute", readLevelControlMinFrequencyAttributeInteractionInfo); + Map readLevelControlMaxFrequencyCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlMaxFrequencyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readMaxFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlMaxFrequencyCommandParams); + result.put("readMaxFrequencyAttribute", readLevelControlMaxFrequencyAttributeInteractionInfo); + Map readLevelControlOptionsCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOptionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOptionsCommandParams); + result.put("readOptionsAttribute", readLevelControlOptionsAttributeInteractionInfo); + Map readLevelControlOnOffTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnOffTransitionTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnOffTransitionTimeCommandParams); + result.put( + "readOnOffTransitionTimeAttribute", + readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnLevelAttribute( + (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterOnLevelAttributeCallback(), + readLevelControlOnLevelCommandParams); + result.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLevelControlClusterOnTransitionTimeAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams); + result.put( + "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOffTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLevelControlClusterOffTransitionTimeAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams); + result.put( + "readOffTransitionTimeAttribute", + readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readDefaultMoveRateAttribute( + (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLevelControlClusterDefaultMoveRateAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams); + result.put( + "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readStartUpCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLevelControlClusterStartUpCurrentLevelAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams); + result.put( + "readStartUpCurrentLevelAttribute", + readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.LevelControlCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLevelControlClusterGeneratedCommandListAttributeCallback(), + readLevelControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readLevelControlGeneratedCommandListAttributeInteractionInfo); + Map readLevelControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.LevelControlCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLevelControlClusterAcceptedCommandListAttributeCallback(), + readLevelControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readLevelControlAcceptedCommandListAttributeInteractionInfo); + Map readLevelControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.LevelControlCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterEventListAttributeCallback(), + readLevelControlEventListCommandParams); + result.put("readEventListAttribute", readLevelControlEventListAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams); + result.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); + Map readLevelControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLevelControlFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readLevelControlFeatureMapAttributeInteractionInfo); + Map readLevelControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBinaryInputBasicInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBinaryInputBasicActiveTextCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicActiveTextAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readActiveTextAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBinaryInputBasicActiveTextCommandParams); + result.put("readActiveTextAttribute", readBinaryInputBasicActiveTextAttributeInteractionInfo); + Map readBinaryInputBasicDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBinaryInputBasicDescriptionCommandParams); + result.put("readDescriptionAttribute", readBinaryInputBasicDescriptionAttributeInteractionInfo); + Map readBinaryInputBasicInactiveTextCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicInactiveTextAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readInactiveTextAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBinaryInputBasicInactiveTextCommandParams); + result.put( + "readInactiveTextAttribute", readBinaryInputBasicInactiveTextAttributeInteractionInfo); + Map readBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBinaryInputBasicOutOfServiceCommandParams); + result.put( + "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPolarityCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPolarityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readPolarityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicPolarityCommandParams); + result.put("readPolarityAttribute", readBinaryInputBasicPolarityAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBinaryInputBasicPresentValueCommandParams); + result.put( + "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicReliabilityCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicReliabilityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readReliabilityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicReliabilityCommandParams); + result.put("readReliabilityAttribute", readBinaryInputBasicReliabilityAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams); + result.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicApplicationTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicApplicationTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readApplicationTypeAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBinaryInputBasicApplicationTypeCommandParams); + result.put( + "readApplicationTypeAttribute", + readBinaryInputBasicApplicationTypeAttributeInteractionInfo); + Map readBinaryInputBasicGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BinaryInputBasicCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBinaryInputBasicClusterGeneratedCommandListAttributeCallback(), + readBinaryInputBasicGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBinaryInputBasicGeneratedCommandListAttributeInteractionInfo); + Map readBinaryInputBasicAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BinaryInputBasicCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBinaryInputBasicClusterAcceptedCommandListAttributeCallback(), + readBinaryInputBasicAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readBinaryInputBasicAcceptedCommandListAttributeInteractionInfo); + Map readBinaryInputBasicEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readEventListAttribute( + (ChipClusters.BinaryInputBasicCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBinaryInputBasicClusterEventListAttributeCallback(), + readBinaryInputBasicEventListCommandParams); + result.put("readEventListAttribute", readBinaryInputBasicEventListAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBinaryInputBasicFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readBinaryInputBasicFeatureMapAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readPulseWidthModulationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readPulseWidthModulationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.PulseWidthModulationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPulseWidthModulationClusterGeneratedCommandListAttributeCallback(), + readPulseWidthModulationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readPulseWidthModulationGeneratedCommandListAttributeInteractionInfo); + Map readPulseWidthModulationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.PulseWidthModulationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPulseWidthModulationClusterAcceptedCommandListAttributeCallback(), + readPulseWidthModulationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readPulseWidthModulationAcceptedCommandListAttributeInteractionInfo); + Map readPulseWidthModulationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readPulseWidthModulationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster) + .readEventListAttribute( + (ChipClusters.PulseWidthModulationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPulseWidthModulationClusterEventListAttributeCallback(), + readPulseWidthModulationEventListCommandParams); + result.put("readEventListAttribute", readPulseWidthModulationEventListAttributeInteractionInfo); + Map readPulseWidthModulationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPulseWidthModulationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PulseWidthModulationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPulseWidthModulationClusterAttributeListAttributeCallback(), + readPulseWidthModulationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readPulseWidthModulationAttributeListAttributeInteractionInfo); + Map readPulseWidthModulationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readPulseWidthModulationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPulseWidthModulationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readPulseWidthModulationFeatureMapAttributeInteractionInfo); + Map readPulseWidthModulationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPulseWidthModulationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PulseWidthModulationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPulseWidthModulationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readPulseWidthModulationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readDescriptorInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readDescriptorDeviceTypeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorDeviceTypeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readDeviceTypeListAttribute( + (ChipClusters.DescriptorCluster.DeviceTypeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedDescriptorClusterDeviceTypeListAttributeCallback(), + readDescriptorDeviceTypeListCommandParams); + result.put("readDeviceTypeListAttribute", readDescriptorDeviceTypeListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readServerListAttribute( + (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), + readDescriptorServerListCommandParams); + result.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); + Map readDescriptorClientListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorClientListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readClientListAttribute( + (ChipClusters.DescriptorCluster.ClientListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterClientListAttributeCallback(), + readDescriptorClientListCommandParams); + result.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); + Map readDescriptorPartsListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorPartsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readPartsListAttribute( + (ChipClusters.DescriptorCluster.PartsListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterPartsListAttributeCallback(), + readDescriptorPartsListCommandParams); + result.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.DescriptorCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDescriptorClusterGeneratedCommandListAttributeCallback(), + readDescriptorGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readDescriptorGeneratedCommandListAttributeInteractionInfo); + Map readDescriptorAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.DescriptorCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDescriptorClusterAcceptedCommandListAttributeCallback(), + readDescriptorAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readDescriptorAcceptedCommandListAttributeInteractionInfo); + Map readDescriptorEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readEventListAttribute( + (ChipClusters.DescriptorCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterEventListAttributeCallback(), + readDescriptorEventListCommandParams); + result.put("readEventListAttribute", readDescriptorEventListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), + readDescriptorAttributeListCommandParams); + result.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDescriptorFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readDescriptorFeatureMapAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBindingInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBindingBindingCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingBindingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readBindingAttribute( + (ChipClusters.BindingCluster.BindingAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterBindingAttributeCallback(), + readBindingBindingCommandParams); + result.put("readBindingAttribute", readBindingBindingAttributeInteractionInfo); + Map readBindingGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BindingCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBindingClusterGeneratedCommandListAttributeCallback(), + readBindingGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBindingGeneratedCommandListAttributeInteractionInfo); + Map readBindingAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BindingCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBindingClusterAcceptedCommandListAttributeCallback(), + readBindingAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readBindingAcceptedCommandListAttributeInteractionInfo); + Map readBindingEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readEventListAttribute( + (ChipClusters.BindingCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterEventListAttributeCallback(), + readBindingEventListCommandParams); + result.put("readEventListAttribute", readBindingEventListAttributeInteractionInfo); + Map readBindingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), + readBindingAttributeListCommandParams); + result.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBindingFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readBindingFeatureMapAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readAccessControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readAccessControlAclCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAclAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAclAttribute( + (ChipClusters.AccessControlCluster.AclAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterAclAttributeCallback(), + readAccessControlAclCommandParams); + result.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); + Map readAccessControlExtensionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlExtensionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readExtensionAttribute( + (ChipClusters.AccessControlCluster.ExtensionAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterExtensionAttributeCallback(), + readAccessControlExtensionCommandParams); + result.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlSubjectsPerAccessControlEntryCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readSubjectsPerAccessControlEntryAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlSubjectsPerAccessControlEntryCommandParams); + result.put( + "readSubjectsPerAccessControlEntryAttribute", + readAccessControlSubjectsPerAccessControlEntryAttributeInteractionInfo); + Map readAccessControlTargetsPerAccessControlEntryCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readTargetsPerAccessControlEntryAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlTargetsPerAccessControlEntryCommandParams); + result.put( + "readTargetsPerAccessControlEntryAttribute", + readAccessControlTargetsPerAccessControlEntryAttributeInteractionInfo); + Map readAccessControlAccessControlEntriesPerFabricCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAccessControlEntriesPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlAccessControlEntriesPerFabricCommandParams); + result.put( + "readAccessControlEntriesPerFabricAttribute", + readAccessControlAccessControlEntriesPerFabricAttributeInteractionInfo); + Map readAccessControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.AccessControlCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccessControlClusterGeneratedCommandListAttributeCallback(), + readAccessControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readAccessControlGeneratedCommandListAttributeInteractionInfo); + Map readAccessControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.AccessControlCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccessControlClusterAcceptedCommandListAttributeCallback(), + readAccessControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readAccessControlAcceptedCommandListAttributeInteractionInfo); + Map readAccessControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.AccessControlCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterEventListAttributeCallback(), + readAccessControlEventListCommandParams); + result.put("readEventListAttribute", readAccessControlEventListAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAccessControlFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readAccessControlFeatureMapAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readActionsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readActionsActionListCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsActionListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readActionListAttribute( + (ChipClusters.ActionsCluster.ActionListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterActionListAttributeCallback(), + readActionsActionListCommandParams); + result.put("readActionListAttribute", readActionsActionListAttributeInteractionInfo); + Map readActionsEndpointListsCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsEndpointListsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readEndpointListsAttribute( + (ChipClusters.ActionsCluster.EndpointListsAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterEndpointListsAttributeCallback(), + readActionsEndpointListsCommandParams); + result.put("readEndpointListsAttribute", readActionsEndpointListsAttributeInteractionInfo); + Map readActionsSetupURLCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsSetupURLAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readSetupURLAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readActionsSetupURLCommandParams); + result.put("readSetupURLAttribute", readActionsSetupURLAttributeInteractionInfo); + Map readActionsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ActionsCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedActionsClusterGeneratedCommandListAttributeCallback(), + readActionsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readActionsGeneratedCommandListAttributeInteractionInfo); + Map readActionsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ActionsCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedActionsClusterAcceptedCommandListAttributeCallback(), + readActionsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readActionsAcceptedCommandListAttributeInteractionInfo); + Map readActionsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readEventListAttribute( + (ChipClusters.ActionsCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterEventListAttributeCallback(), + readActionsEventListCommandParams); + result.put("readEventListAttribute", readActionsEventListAttributeInteractionInfo); + Map readActionsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ActionsCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedActionsClusterAttributeListAttributeCallback(), + readActionsAttributeListCommandParams); + result.put("readAttributeListAttribute", readActionsAttributeListAttributeInteractionInfo); + Map readActionsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readActionsFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readActionsFeatureMapAttributeInteractionInfo); + Map readActionsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readActionsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActionsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActionsClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readActionsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBasicInformationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBasicInformationDataModelRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationDataModelRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readDataModelRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationDataModelRevisionCommandParams); + result.put( + "readDataModelRevisionAttribute", + readBasicInformationDataModelRevisionAttributeInteractionInfo); + Map readBasicInformationVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationVendorNameCommandParams); + result.put("readVendorNameAttribute", readBasicInformationVendorNameAttributeInteractionInfo); + Map readBasicInformationVendorIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationVendorIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationVendorIDCommandParams); + result.put("readVendorIDAttribute", readBasicInformationVendorIDAttributeInteractionInfo); + Map readBasicInformationProductNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationProductNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationProductNameCommandParams); + result.put("readProductNameAttribute", readBasicInformationProductNameAttributeInteractionInfo); + Map readBasicInformationProductIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationProductIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationProductIDCommandParams); + result.put("readProductIDAttribute", readBasicInformationProductIDAttributeInteractionInfo); + Map readBasicInformationNodeLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationNodeLabelCommandParams); + result.put("readNodeLabelAttribute", readBasicInformationNodeLabelAttributeInteractionInfo); + Map readBasicInformationLocationCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationLocationCommandParams); + result.put("readLocationAttribute", readBasicInformationLocationAttributeInteractionInfo); + Map readBasicInformationHardwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationHardwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationHardwareVersionCommandParams); + result.put( + "readHardwareVersionAttribute", + readBasicInformationHardwareVersionAttributeInteractionInfo); + Map readBasicInformationHardwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationHardwareVersionStringCommandParams); + result.put( + "readHardwareVersionStringAttribute", + readBasicInformationHardwareVersionStringAttributeInteractionInfo); + Map readBasicInformationSoftwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBasicInformationSoftwareVersionCommandParams); + result.put( + "readSoftwareVersionAttribute", + readBasicInformationSoftwareVersionAttributeInteractionInfo); + Map readBasicInformationSoftwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationSoftwareVersionStringCommandParams); + result.put( + "readSoftwareVersionStringAttribute", + readBasicInformationSoftwareVersionStringAttributeInteractionInfo); + Map readBasicInformationManufacturingDateCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationManufacturingDateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationManufacturingDateCommandParams); + result.put( + "readManufacturingDateAttribute", + readBasicInformationManufacturingDateAttributeInteractionInfo); + Map readBasicInformationPartNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationPartNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationPartNumberCommandParams); + result.put("readPartNumberAttribute", readBasicInformationPartNumberAttributeInteractionInfo); + Map readBasicInformationProductURLCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationProductURLAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationProductURLCommandParams); + result.put("readProductURLAttribute", readBasicInformationProductURLAttributeInteractionInfo); + Map readBasicInformationProductLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationProductLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationProductLabelCommandParams); + result.put( + "readProductLabelAttribute", readBasicInformationProductLabelAttributeInteractionInfo); + Map readBasicInformationSerialNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationSerialNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationSerialNumberCommandParams); + result.put( + "readSerialNumberAttribute", readBasicInformationSerialNumberAttributeInteractionInfo); + Map readBasicInformationLocalConfigDisabledCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readLocalConfigDisabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBasicInformationLocalConfigDisabledCommandParams); + result.put( + "readLocalConfigDisabledAttribute", + readBasicInformationLocalConfigDisabledAttributeInteractionInfo); + Map readBasicInformationReachableCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationReachableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBasicInformationReachableCommandParams); + result.put("readReachableAttribute", readBasicInformationReachableAttributeInteractionInfo); + Map readBasicInformationUniqueIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationUniqueIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBasicInformationUniqueIDCommandParams); + result.put("readUniqueIDAttribute", readBasicInformationUniqueIDAttributeInteractionInfo); + Map readBasicInformationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BasicInformationCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBasicInformationClusterGeneratedCommandListAttributeCallback(), + readBasicInformationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBasicInformationGeneratedCommandListAttributeInteractionInfo); + Map readBasicInformationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BasicInformationCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBasicInformationClusterAcceptedCommandListAttributeCallback(), + readBasicInformationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readBasicInformationAcceptedCommandListAttributeInteractionInfo); + Map readBasicInformationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readEventListAttribute( + (ChipClusters.BasicInformationCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBasicInformationClusterEventListAttributeCallback(), + readBasicInformationEventListCommandParams); + result.put("readEventListAttribute", readBasicInformationEventListAttributeInteractionInfo); + Map readBasicInformationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BasicInformationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBasicInformationClusterAttributeListAttributeCallback(), + readBasicInformationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readBasicInformationAttributeListAttributeInteractionInfo); + Map readBasicInformationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBasicInformationFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readBasicInformationFeatureMapAttributeInteractionInfo); + Map readBasicInformationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInformationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInformationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readBasicInformationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOtaSoftwareUpdateProviderInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map + readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterGeneratedCommandListAttributeCallback(), + readOtaSoftwareUpdateProviderGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readOtaSoftwareUpdateProviderGeneratedCommandListAttributeInteractionInfo); + Map + readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterAcceptedCommandListAttributeCallback(), + readOtaSoftwareUpdateProviderAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readOtaSoftwareUpdateProviderAcceptedCommandListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readEventListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterEventListAttributeCallback(), + readOtaSoftwareUpdateProviderEventListCommandParams); + result.put( + "readEventListAttribute", readOtaSoftwareUpdateProviderEventListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOtaSoftwareUpdateProviderFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readOtaSoftwareUpdateProviderFeatureMapAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOtaSoftwareUpdateRequestorInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map + readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readDefaultOTAProvidersAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .DefaultOTAProvidersAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterDefaultOTAProvidersAttributeCallback(), + readOtaSoftwareUpdateRequestorDefaultOTAProvidersCommandParams); + result.put( + "readDefaultOTAProvidersAttribute", + readOtaSoftwareUpdateRequestorDefaultOTAProvidersAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readUpdatePossibleAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams); + result.put( + "readUpdatePossibleAttribute", + readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdateStateCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readUpdateStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateCommandParams); + result.put( + "readUpdateStateAttribute", + readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readUpdateStateProgressAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .UpdateStateProgressAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterUpdateStateProgressAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); + result.put( + "readUpdateStateProgressAttribute", + readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map + readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterGeneratedCommandListAttributeCallback(), + readOtaSoftwareUpdateRequestorGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readOtaSoftwareUpdateRequestorGeneratedCommandListAttributeInteractionInfo); + Map + readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterAcceptedCommandListAttributeCallback(), + readOtaSoftwareUpdateRequestorAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readOtaSoftwareUpdateRequestorAcceptedCommandListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readEventListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterEventListAttributeCallback(), + readOtaSoftwareUpdateRequestorEventListCommandParams); + result.put( + "readEventListAttribute", readOtaSoftwareUpdateRequestorEventListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOtaSoftwareUpdateRequestorFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readOtaSoftwareUpdateRequestorFeatureMapAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readLocalizationConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readLocalizationConfigurationActiveLocaleCommandParams); + result.put( + "readActiveLocaleAttribute", + readLocalizationConfigurationActiveLocaleAttributeInteractionInfo); + Map readLocalizationConfigurationSupportedLocalesCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readSupportedLocalesAttribute( + (ChipClusters.LocalizationConfigurationCluster + .SupportedLocalesAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback(), + readLocalizationConfigurationSupportedLocalesCommandParams); + result.put( + "readSupportedLocalesAttribute", + readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map + readLocalizationConfigurationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.LocalizationConfigurationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLocalizationConfigurationClusterGeneratedCommandListAttributeCallback(), + readLocalizationConfigurationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readLocalizationConfigurationGeneratedCommandListAttributeInteractionInfo); + Map + readLocalizationConfigurationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.LocalizationConfigurationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLocalizationConfigurationClusterAcceptedCommandListAttributeCallback(), + readLocalizationConfigurationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readLocalizationConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readLocalizationConfigurationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readEventListAttribute( + (ChipClusters.LocalizationConfigurationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLocalizationConfigurationClusterEventListAttributeCallback(), + readLocalizationConfigurationEventListCommandParams); + result.put( + "readEventListAttribute", readLocalizationConfigurationEventListAttributeInteractionInfo); + Map readLocalizationConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LocalizationConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLocalizationConfigurationClusterAttributeListAttributeCallback(), + readLocalizationConfigurationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readLocalizationConfigurationAttributeListAttributeInteractionInfo); + Map readLocalizationConfigurationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLocalizationConfigurationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readLocalizationConfigurationFeatureMapAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readTimeFormatLocalizationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams); + result.put( + "readHourFormatAttribute", readTimeFormatLocalizationHourFormatAttributeInteractionInfo); + Map readTimeFormatLocalizationActiveCalendarTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readActiveCalendarTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationActiveCalendarTypeCommandParams); + result.put( + "readActiveCalendarTypeAttribute", + readTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); + Map + readTimeFormatLocalizationSupportedCalendarTypesCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readSupportedCalendarTypesAttribute( + (ChipClusters.TimeFormatLocalizationCluster + .SupportedCalendarTypesAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback(), + readTimeFormatLocalizationSupportedCalendarTypesCommandParams); + result.put( + "readSupportedCalendarTypesAttribute", + readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.TimeFormatLocalizationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeFormatLocalizationClusterGeneratedCommandListAttributeCallback(), + readTimeFormatLocalizationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readTimeFormatLocalizationGeneratedCommandListAttributeInteractionInfo); + Map readTimeFormatLocalizationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.TimeFormatLocalizationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeFormatLocalizationClusterAcceptedCommandListAttributeCallback(), + readTimeFormatLocalizationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readTimeFormatLocalizationAcceptedCommandListAttributeInteractionInfo); + Map readTimeFormatLocalizationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readEventListAttribute( + (ChipClusters.TimeFormatLocalizationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeFormatLocalizationClusterEventListAttributeCallback(), + readTimeFormatLocalizationEventListCommandParams); + result.put( + "readEventListAttribute", readTimeFormatLocalizationEventListAttributeInteractionInfo); + Map readTimeFormatLocalizationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TimeFormatLocalizationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeFormatLocalizationClusterAttributeListAttributeCallback(), + readTimeFormatLocalizationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readTimeFormatLocalizationAttributeListAttributeInteractionInfo); + Map readTimeFormatLocalizationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTimeFormatLocalizationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readTimeFormatLocalizationFeatureMapAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readUnitLocalizationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams); + result.put( + "readTemperatureUnitAttribute", + readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.UnitLocalizationCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitLocalizationClusterGeneratedCommandListAttributeCallback(), + readUnitLocalizationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readUnitLocalizationGeneratedCommandListAttributeInteractionInfo); + Map readUnitLocalizationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.UnitLocalizationCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitLocalizationClusterAcceptedCommandListAttributeCallback(), + readUnitLocalizationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readUnitLocalizationAcceptedCommandListAttributeInteractionInfo); + Map readUnitLocalizationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readEventListAttribute( + (ChipClusters.UnitLocalizationCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitLocalizationClusterEventListAttributeCallback(), + readUnitLocalizationEventListCommandParams); + result.put("readEventListAttribute", readUnitLocalizationEventListAttributeInteractionInfo); + Map readUnitLocalizationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.UnitLocalizationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitLocalizationClusterAttributeListAttributeCallback(), + readUnitLocalizationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readUnitLocalizationAttributeListAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitLocalizationFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readUnitLocalizationFeatureMapAttributeInteractionInfo); + Map readUnitLocalizationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readUnitLocalizationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readPowerSourceConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readPowerSourceConfigurationSourcesCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationSourcesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readSourcesAttribute( + (ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback(), + readPowerSourceConfigurationSourcesCommandParams); + result.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map + readPowerSourceConfigurationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.PowerSourceConfigurationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterGeneratedCommandListAttributeCallback(), + readPowerSourceConfigurationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readPowerSourceConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readPowerSourceConfigurationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.PowerSourceConfigurationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterAcceptedCommandListAttributeCallback(), + readPowerSourceConfigurationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readPowerSourceConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readPowerSourceConfigurationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readEventListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterEventListAttributeCallback(), + readPowerSourceConfigurationEventListCommandParams); + result.put( + "readEventListAttribute", readPowerSourceConfigurationEventListAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceConfigurationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readPowerSourceConfigurationFeatureMapAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readPowerSourceInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readPowerSourceStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams); + result.put("readStatusAttribute", readPowerSourceStatusAttributeInteractionInfo); + Map readPowerSourceOrderCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceOrderAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readOrderAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceOrderCommandParams); + result.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); + Map readPowerSourceDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceDescriptionCommandParams); + result.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceWiredAssessedInputVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredAssessedInputVoltageAttribute( + (ChipClusters.PowerSourceCluster.WiredAssessedInputVoltageAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterWiredAssessedInputVoltageAttributeCallback(), + readPowerSourceWiredAssessedInputVoltageCommandParams); + result.put( + "readWiredAssessedInputVoltageAttribute", + readPowerSourceWiredAssessedInputVoltageAttributeInteractionInfo); + Map readPowerSourceWiredAssessedInputFrequencyCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredAssessedInputFrequencyAttribute( + (ChipClusters.PowerSourceCluster.WiredAssessedInputFrequencyAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterWiredAssessedInputFrequencyAttributeCallback(), + readPowerSourceWiredAssessedInputFrequencyCommandParams); + result.put( + "readWiredAssessedInputFrequencyAttribute", + readPowerSourceWiredAssessedInputFrequencyAttributeInteractionInfo); + Map readPowerSourceWiredCurrentTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredCurrentTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredCurrentTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceWiredCurrentTypeCommandParams); + result.put( + "readWiredCurrentTypeAttribute", readPowerSourceWiredCurrentTypeAttributeInteractionInfo); + Map readPowerSourceWiredAssessedCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredAssessedCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredAssessedCurrentAttribute( + (ChipClusters.PowerSourceCluster.WiredAssessedCurrentAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterWiredAssessedCurrentAttributeCallback(), + readPowerSourceWiredAssessedCurrentCommandParams); + result.put( + "readWiredAssessedCurrentAttribute", + readPowerSourceWiredAssessedCurrentAttributeInteractionInfo); + Map readPowerSourceWiredNominalVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredNominalVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredNominalVoltageAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceWiredNominalVoltageCommandParams); + result.put( + "readWiredNominalVoltageAttribute", + readPowerSourceWiredNominalVoltageAttributeInteractionInfo); + Map readPowerSourceWiredMaximumCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredMaximumCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredMaximumCurrentAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceWiredMaximumCurrentCommandParams); + result.put( + "readWiredMaximumCurrentAttribute", + readPowerSourceWiredMaximumCurrentAttributeInteractionInfo); + Map readPowerSourceWiredPresentCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceWiredPresentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readWiredPresentAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceWiredPresentCommandParams); + result.put("readWiredPresentAttribute", readPowerSourceWiredPresentAttributeInteractionInfo); + Map readPowerSourceActiveWiredFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceActiveWiredFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readActiveWiredFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveWiredFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterActiveWiredFaultsAttributeCallback(), + readPowerSourceActiveWiredFaultsCommandParams); + result.put( + "readActiveWiredFaultsAttribute", readPowerSourceActiveWiredFaultsAttributeInteractionInfo); + Map readPowerSourceBatVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatVoltageAttribute( + (ChipClusters.PowerSourceCluster.BatVoltageAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterBatVoltageAttributeCallback(), + readPowerSourceBatVoltageCommandParams); + result.put("readBatVoltageAttribute", readPowerSourceBatVoltageAttributeInteractionInfo); + Map readPowerSourceBatPercentRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatPercentRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatPercentRemainingAttribute( + (ChipClusters.PowerSourceCluster.BatPercentRemainingAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterBatPercentRemainingAttributeCallback(), + readPowerSourceBatPercentRemainingCommandParams); + result.put( + "readBatPercentRemainingAttribute", + readPowerSourceBatPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatTimeRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatTimeRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatTimeRemainingAttribute( + (ChipClusters.PowerSourceCluster.BatTimeRemainingAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterBatTimeRemainingAttributeCallback(), + readPowerSourceBatTimeRemainingCommandParams); + result.put( + "readBatTimeRemainingAttribute", readPowerSourceBatTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatChargeLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatChargeLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatChargeLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatChargeLevelCommandParams); + result.put( + "readBatChargeLevelAttribute", readPowerSourceBatChargeLevelAttributeInteractionInfo); + Map readPowerSourceBatReplacementNeededCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatReplacementNeededAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatReplacementNeededAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceBatReplacementNeededCommandParams); + result.put( + "readBatReplacementNeededAttribute", + readPowerSourceBatReplacementNeededAttributeInteractionInfo); + Map readPowerSourceBatReplaceabilityCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatReplaceabilityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatReplaceabilityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatReplaceabilityCommandParams); + result.put( + "readBatReplaceabilityAttribute", readPowerSourceBatReplaceabilityAttributeInteractionInfo); + Map readPowerSourceBatPresentCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatPresentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatPresentAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceBatPresentCommandParams); + result.put("readBatPresentAttribute", readPowerSourceBatPresentAttributeInteractionInfo); + Map readPowerSourceActiveBatFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readActiveBatFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatFaultsAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterActiveBatFaultsAttributeCallback(), + readPowerSourceActiveBatFaultsCommandParams); + result.put( + "readActiveBatFaultsAttribute", readPowerSourceActiveBatFaultsAttributeInteractionInfo); + Map readPowerSourceBatReplacementDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatReplacementDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatReplacementDescriptionAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceBatReplacementDescriptionCommandParams); + result.put( + "readBatReplacementDescriptionAttribute", + readPowerSourceBatReplacementDescriptionAttributeInteractionInfo); + Map readPowerSourceBatCommonDesignationCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatCommonDesignationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatCommonDesignationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatCommonDesignationCommandParams); + result.put( + "readBatCommonDesignationAttribute", + readPowerSourceBatCommonDesignationAttributeInteractionInfo); + Map readPowerSourceBatANSIDesignationCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatANSIDesignationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatANSIDesignationAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceBatANSIDesignationCommandParams); + result.put( + "readBatANSIDesignationAttribute", + readPowerSourceBatANSIDesignationAttributeInteractionInfo); + Map readPowerSourceBatIECDesignationCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatIECDesignationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatIECDesignationAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readPowerSourceBatIECDesignationCommandParams); + result.put( + "readBatIECDesignationAttribute", readPowerSourceBatIECDesignationAttributeInteractionInfo); + Map readPowerSourceBatApprovedChemistryCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatApprovedChemistryAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatApprovedChemistryAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatApprovedChemistryCommandParams); + result.put( + "readBatApprovedChemistryAttribute", + readPowerSourceBatApprovedChemistryAttributeInteractionInfo); + Map readPowerSourceBatCapacityCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatCapacityAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceBatCapacityCommandParams); + result.put("readBatCapacityAttribute", readPowerSourceBatCapacityAttributeInteractionInfo); + Map readPowerSourceBatQuantityCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatQuantityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatQuantityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatQuantityCommandParams); + result.put("readBatQuantityAttribute", readPowerSourceBatQuantityAttributeInteractionInfo); + Map readPowerSourceBatChargeStateCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatChargeStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatChargeStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatChargeStateCommandParams); + result.put( + "readBatChargeStateAttribute", readPowerSourceBatChargeStateAttributeInteractionInfo); + Map readPowerSourceBatTimeToFullChargeCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatTimeToFullChargeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatTimeToFullChargeAttribute( + (ChipClusters.PowerSourceCluster.BatTimeToFullChargeAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterBatTimeToFullChargeAttributeCallback(), + readPowerSourceBatTimeToFullChargeCommandParams); + result.put( + "readBatTimeToFullChargeAttribute", + readPowerSourceBatTimeToFullChargeAttributeInteractionInfo); + Map readPowerSourceBatFunctionalWhileChargingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatFunctionalWhileChargingAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readPowerSourceBatFunctionalWhileChargingCommandParams); + result.put( + "readBatFunctionalWhileChargingAttribute", + readPowerSourceBatFunctionalWhileChargingAttributeInteractionInfo); + Map readPowerSourceBatChargingCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatChargingCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatChargingCurrentAttribute( + (ChipClusters.PowerSourceCluster.BatChargingCurrentAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterBatChargingCurrentAttributeCallback(), + readPowerSourceBatChargingCurrentCommandParams); + result.put( + "readBatChargingCurrentAttribute", + readPowerSourceBatChargingCurrentAttributeInteractionInfo); + Map readPowerSourceActiveBatChargeFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readActiveBatChargeFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatChargeFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterActiveBatChargeFaultsAttributeCallback(), + readPowerSourceActiveBatChargeFaultsCommandParams); + result.put( + "readActiveBatChargeFaultsAttribute", + readPowerSourceActiveBatChargeFaultsAttributeInteractionInfo); + Map readPowerSourceGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.PowerSourceCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterGeneratedCommandListAttributeCallback(), + readPowerSourceGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readPowerSourceGeneratedCommandListAttributeInteractionInfo); + Map readPowerSourceAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.PowerSourceCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterAcceptedCommandListAttributeCallback(), + readPowerSourceAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readPowerSourceAcceptedCommandListAttributeInteractionInfo); + Map readPowerSourceEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readEventListAttribute( + (ChipClusters.PowerSourceCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterEventListAttributeCallback(), + readPowerSourceEventListCommandParams); + result.put("readEventListAttribute", readPowerSourceEventListAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams); + result.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); + Map readPowerSourceFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPowerSourceFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readPowerSourceFeatureMapAttributeInteractionInfo); + Map readPowerSourceClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readGeneralCommissioningInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralCommissioningBreadcrumbCommandParams); + result.put( + "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams); + result.put( + "readRegulatoryConfigAttribute", + readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo); + Map readGeneralCommissioningLocationCapabilityCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningLocationCapabilityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readLocationCapabilityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningLocationCapabilityCommandParams); + result.put( + "readLocationCapabilityAttribute", + readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map + readGeneralCommissioningSupportsConcurrentConnectionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readSupportsConcurrentConnectionAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readGeneralCommissioningSupportsConcurrentConnectionCommandParams); + result.put( + "readSupportsConcurrentConnectionAttribute", + readGeneralCommissioningSupportsConcurrentConnectionAttributeInteractionInfo); + Map readGeneralCommissioningGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.GeneralCommissioningCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterGeneratedCommandListAttributeCallback(), + readGeneralCommissioningGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readGeneralCommissioningGeneratedCommandListAttributeInteractionInfo); + Map readGeneralCommissioningAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.GeneralCommissioningCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterAcceptedCommandListAttributeCallback(), + readGeneralCommissioningAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readGeneralCommissioningAcceptedCommandListAttributeInteractionInfo); + Map readGeneralCommissioningEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readEventListAttribute( + (ChipClusters.GeneralCommissioningCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterEventListAttributeCallback(), + readGeneralCommissioningEventListCommandParams); + result.put("readEventListAttribute", readGeneralCommissioningEventListAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralCommissioningFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readGeneralCommissioningFeatureMapAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readNetworkCommissioningInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readNetworkCommissioningMaxNetworksCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams); + result.put( + "readMaxNetworksAttribute", readNetworkCommissioningMaxNetworksAttributeInteractionInfo); + Map readNetworkCommissioningNetworksCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningNetworksAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readNetworksAttribute( + (ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterNetworksAttributeCallback(), + readNetworkCommissioningNetworksCommandParams); + result.put("readNetworksAttribute", readNetworkCommissioningNetworksAttributeInteractionInfo); + Map readNetworkCommissioningScanMaxTimeSecondsCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readScanMaxTimeSecondsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningScanMaxTimeSecondsCommandParams); + result.put( + "readScanMaxTimeSecondsAttribute", + readNetworkCommissioningScanMaxTimeSecondsAttributeInteractionInfo); + Map readNetworkCommissioningConnectMaxTimeSecondsCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readConnectMaxTimeSecondsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningConnectMaxTimeSecondsCommandParams); + result.put( + "readConnectMaxTimeSecondsAttribute", + readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); + Map readNetworkCommissioningInterfaceEnabledCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readInterfaceEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readNetworkCommissioningInterfaceEnabledCommandParams); + result.put( + "readInterfaceEnabledAttribute", + readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkingStatusAttribute( + (ChipClusters.NetworkCommissioningCluster + .LastNetworkingStatusAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterLastNetworkingStatusAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams); + result.put( + "readLastNetworkingStatusAttribute", + readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkIDAttribute( + (ChipClusters.NetworkCommissioningCluster.LastNetworkIDAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterLastNetworkIDAttributeCallback(), + readNetworkCommissioningLastNetworkIDCommandParams); + result.put( + "readLastNetworkIDAttribute", + readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastConnectErrorValueAttribute( + (ChipClusters.NetworkCommissioningCluster + .LastConnectErrorValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterLastConnectErrorValueAttributeCallback(), + readNetworkCommissioningLastConnectErrorValueCommandParams); + result.put( + "readLastConnectErrorValueAttribute", + readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.NetworkCommissioningCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterGeneratedCommandListAttributeCallback(), + readNetworkCommissioningGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readNetworkCommissioningGeneratedCommandListAttributeInteractionInfo); + Map readNetworkCommissioningAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.NetworkCommissioningCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterAcceptedCommandListAttributeCallback(), + readNetworkCommissioningAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readNetworkCommissioningAcceptedCommandListAttributeInteractionInfo); + Map readNetworkCommissioningEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readEventListAttribute( + (ChipClusters.NetworkCommissioningCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterEventListAttributeCallback(), + readNetworkCommissioningEventListCommandParams); + result.put("readEventListAttribute", readNetworkCommissioningEventListAttributeInteractionInfo); + Map readNetworkCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.NetworkCommissioningCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedNetworkCommissioningClusterAttributeListAttributeCallback(), + readNetworkCommissioningAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readNetworkCommissioningAttributeListAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readNetworkCommissioningFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readNetworkCommissioningFeatureMapAttributeInteractionInfo); + Map readNetworkCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readDiagnosticLogsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readDiagnosticLogsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.DiagnosticLogsCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDiagnosticLogsClusterGeneratedCommandListAttributeCallback(), + readDiagnosticLogsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readDiagnosticLogsGeneratedCommandListAttributeInteractionInfo); + Map readDiagnosticLogsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.DiagnosticLogsCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDiagnosticLogsClusterAcceptedCommandListAttributeCallback(), + readDiagnosticLogsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readDiagnosticLogsAcceptedCommandListAttributeInteractionInfo); + Map readDiagnosticLogsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readEventListAttribute( + (ChipClusters.DiagnosticLogsCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterEventListAttributeCallback(), + readDiagnosticLogsEventListCommandParams); + result.put("readEventListAttribute", readDiagnosticLogsEventListAttributeInteractionInfo); + Map readDiagnosticLogsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + Map readDiagnosticLogsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDiagnosticLogsFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readDiagnosticLogsFeatureMapAttributeInteractionInfo); + Map readDiagnosticLogsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDiagnosticLogsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readDiagnosticLogsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readGeneralDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readGeneralDiagnosticsNetworkInterfacesCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readNetworkInterfacesAttribute( + (ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback(), + readGeneralDiagnosticsNetworkInterfacesCommandParams); + result.put( + "readNetworkInterfacesAttribute", + readGeneralDiagnosticsNetworkInterfacesAttributeInteractionInfo); + Map readGeneralDiagnosticsRebootCountCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsRebootCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readRebootCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsRebootCountCommandParams); + result.put( + "readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); + Map readGeneralDiagnosticsUpTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readUpTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralDiagnosticsUpTimeCommandParams); + result.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); + Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readTotalOperationalHoursAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralDiagnosticsTotalOperationalHoursCommandParams); + result.put( + "readTotalOperationalHoursAttribute", + readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readBootReasonAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonCommandParams); + result.put("readBootReasonAttribute", readGeneralDiagnosticsBootReasonAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readActiveHardwareFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams); + result.put( + "readActiveHardwareFaultsAttribute", + readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveRadioFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readActiveRadioFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback(), + readGeneralDiagnosticsActiveRadioFaultsCommandParams); + result.put( + "readActiveRadioFaultsAttribute", + readGeneralDiagnosticsActiveRadioFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveNetworkFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readActiveNetworkFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback(), + readGeneralDiagnosticsActiveNetworkFaultsCommandParams); + result.put( + "readActiveNetworkFaultsAttribute", + readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsTestEventTriggersEnabledCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readTestEventTriggersEnabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readGeneralDiagnosticsTestEventTriggersEnabledCommandParams); + result.put( + "readTestEventTriggersEnabledAttribute", + readGeneralDiagnosticsTestEventTriggersEnabledAttributeInteractionInfo); + Map readGeneralDiagnosticsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readGeneralDiagnosticsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readGeneralDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readGeneralDiagnosticsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readGeneralDiagnosticsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readGeneralDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readGeneralDiagnosticsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readEventListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterEventListAttributeCallback(), + readGeneralDiagnosticsEventListCommandParams); + result.put("readEventListAttribute", readGeneralDiagnosticsEventListAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGeneralDiagnosticsFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readGeneralDiagnosticsFeatureMapAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readSoftwareDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readSoftwareDiagnosticsThreadMetricsCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readThreadMetricsAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback(), + readSoftwareDiagnosticsThreadMetricsCommandParams); + result.put( + "readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); + Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readCurrentHeapFreeAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsCurrentHeapFreeCommandParams); + result.put( + "readCurrentHeapFreeAttribute", + readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); + Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readCurrentHeapUsedAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsCurrentHeapUsedCommandParams); + result.put( + "readCurrentHeapUsedAttribute", + readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); + Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readCurrentHeapHighWatermarkAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams); + result.put( + "readCurrentHeapHighWatermarkAttribute", + readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readSoftwareDiagnosticsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readSoftwareDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readSoftwareDiagnosticsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readSoftwareDiagnosticsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readSoftwareDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readSoftwareDiagnosticsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readEventListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterEventListAttributeCallback(), + readSoftwareDiagnosticsEventListCommandParams); + result.put("readEventListAttribute", readSoftwareDiagnosticsEventListAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); + Map readSoftwareDiagnosticsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSoftwareDiagnosticsFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo); + Map readSoftwareDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSoftwareDiagnosticsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readThreadNetworkDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readThreadNetworkDiagnosticsChannelCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ChannelAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterChannelAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams); + result.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRoutingRoleAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RoutingRoleAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams); + result.put( + "readRoutingRoleAttribute", + readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNetworkNameAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.NetworkNameAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterNetworkNameAttributeCallback(), + readThreadNetworkDiagnosticsNetworkNameCommandParams); + result.put( + "readNetworkNameAttribute", + readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPanIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.PanIdAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterPanIdAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams); + result.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readExtendedPanIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.ExtendedPanIdAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterExtendedPanIdAttributeCallback(), + readThreadNetworkDiagnosticsExtendedPanIdCommandParams); + result.put( + "readExtendedPanIdAttribute", + readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readMeshLocalPrefixAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .MeshLocalPrefixAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterMeshLocalPrefixAttributeCallback(), + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); + result.put( + "readMeshLocalPrefixAttribute", + readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsOverrunCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsOverrunCountCommandParams); + result.put( + "readOverrunCountAttribute", + readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNeighborTableAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterNeighborTableAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableCommandParams); + result.put( + "readNeighborTableAttribute", + readThreadNetworkDiagnosticsNeighborTableAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRouteTableAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterRouteTableAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableCommandParams); + result.put( + "readRouteTableAttribute", readThreadNetworkDiagnosticsRouteTableAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPartitionIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.PartitionIdAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterPartitionIdAttributeCallback(), + readThreadNetworkDiagnosticsPartitionIdCommandParams); + result.put( + "readPartitionIdAttribute", + readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readWeightingAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.WeightingAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterWeightingAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams); + result.put( + "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDataVersionAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.DataVersionAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterDataVersionAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams); + result.put( + "readDataVersionAttribute", + readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readStableDataVersionAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .StableDataVersionAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterStableDataVersionAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams); + result.put( + "readStableDataVersionAttribute", + readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readLeaderRouterIdAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.LeaderRouterIdAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterLeaderRouterIdAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); + result.put( + "readLeaderRouterIdAttribute", + readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDetachedRoleCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDetachedRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDetachedRoleCountCommandParams); + result.put( + "readDetachedRoleCountAttribute", + readThreadNetworkDiagnosticsDetachedRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChildRoleCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChildRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChildRoleCountCommandParams); + result.put( + "readChildRoleCountAttribute", + readThreadNetworkDiagnosticsChildRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouterRoleCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRouterRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRouterRoleCountCommandParams); + result.put( + "readRouterRoleCountAttribute", + readThreadNetworkDiagnosticsRouterRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRoleCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readLeaderRoleCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRoleCountCommandParams); + result.put( + "readLeaderRoleCountAttribute", + readThreadNetworkDiagnosticsLeaderRoleCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttachAttemptCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readAttachAttemptCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsAttachAttemptCountCommandParams); + result.put( + "readAttachAttemptCountAttribute", + readThreadNetworkDiagnosticsAttachAttemptCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPartitionIdChangeCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPartitionIdChangeCountCommandParams); + result.put( + "readPartitionIdChangeCountAttribute", + readThreadNetworkDiagnosticsPartitionIdChangeCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams = + new LinkedHashMap(); + InteractionInfo + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readBetterPartitionAttachAttemptCountAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountCommandParams); + result.put( + "readBetterPartitionAttachAttemptCountAttribute", + readThreadNetworkDiagnosticsBetterPartitionAttachAttemptCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsParentChangeCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readParentChangeCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsParentChangeCountCommandParams); + result.put( + "readParentChangeCountAttribute", + readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxTotalCountCommandParams); + result.put( + "readTxTotalCountAttribute", + readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxUnicastCountCommandParams); + result.put( + "readTxUnicastCountAttribute", + readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams); + result.put( + "readTxBroadcastCountAttribute", + readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxAckRequestedCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams); + result.put( + "readTxAckRequestedCountAttribute", + readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxAckedCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxAckedCountCommandParams); + result.put( + "readTxAckedCountAttribute", + readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxNoAckRequestedCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams); + result.put( + "readTxNoAckRequestedCountAttribute", + readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDataCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDataCountCommandParams); + result.put( + "readTxDataCountAttribute", + readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDataPollCountCommandParams); + result.put( + "readTxDataPollCountAttribute", + readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxBeaconCountCommandParams); + result.put( + "readTxBeaconCountAttribute", + readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams); + result.put( + "readTxBeaconRequestCountAttribute", + readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxOtherCountCommandParams); + result.put( + "readTxOtherCountAttribute", + readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxRetryCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxRetryCountCommandParams); + result.put( + "readTxRetryCountAttribute", + readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = + new LinkedHashMap(); + InteractionInfo + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxDirectMaxRetryExpiryCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams); + result.put( + "readTxDirectMaxRetryExpiryCountAttribute", + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = + new LinkedHashMap(); + InteractionInfo + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxIndirectMaxRetryExpiryCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams); + result.put( + "readTxIndirectMaxRetryExpiryCountAttribute", + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); + result.put( + "readTxErrCcaCountAttribute", + readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); + result.put( + "readTxErrAbortCountAttribute", + readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrBusyChannelCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); + result.put( + "readTxErrBusyChannelCountAttribute", + readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxTotalCountCommandParams); + result.put( + "readRxTotalCountAttribute", + readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxUnicastCountCommandParams); + result.put( + "readRxUnicastCountAttribute", + readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); + result.put( + "readRxBroadcastCountAttribute", + readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDataCountCommandParams); + result.put( + "readRxDataCountAttribute", + readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDataPollCountCommandParams); + result.put( + "readRxDataPollCountAttribute", + readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxBeaconCountCommandParams); + result.put( + "readRxBeaconCountAttribute", + readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); + result.put( + "readRxBeaconRequestCountAttribute", + readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxOtherCountCommandParams); + result.put( + "readRxOtherCountAttribute", + readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxAddressFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); + result.put( + "readRxAddressFilteredCountAttribute", + readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDestAddrFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); + result.put( + "readRxDestAddrFilteredCountAttribute", + readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); + result.put( + "readRxDuplicatedCountAttribute", + readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); + result.put( + "readRxErrNoFrameCountAttribute", + readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrUnknownNeighborCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); + result.put( + "readRxErrUnknownNeighborCountAttribute", + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrInvalidSrcAddrCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); + result.put( + "readRxErrInvalidSrcAddrCountAttribute", + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrSecCountCommandParams); + result.put( + "readRxErrSecCountAttribute", + readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); + result.put( + "readRxErrFcsCountAttribute", + readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); + result.put( + "readRxErrOtherCountAttribute", + readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveTimestampAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveTimestampAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterActiveTimestampAttributeCallback(), + readThreadNetworkDiagnosticsActiveTimestampCommandParams); + result.put( + "readActiveTimestampAttribute", + readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPendingTimestampAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .PendingTimestampAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterPendingTimestampAttributeCallback(), + readThreadNetworkDiagnosticsPendingTimestampCommandParams); + result.put( + "readPendingTimestampAttribute", + readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDelayAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.DelayAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterDelayAttributeCallback(), + readThreadNetworkDiagnosticsDelayCommandParams); + result.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelPage0MaskCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelPage0MaskAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .ChannelPage0MaskAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterChannelPage0MaskAttributeCallback(), + readThreadNetworkDiagnosticsChannelPage0MaskCommandParams); + result.put( + "readChannelPage0MaskAttribute", + readThreadNetworkDiagnosticsChannelPage0MaskAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveNetworkFaultsListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); + result.put( + "readActiveNetworkFaultsListAttribute", + readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readThreadNetworkDiagnosticsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readThreadNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readThreadNetworkDiagnosticsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readThreadNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readEventListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterEventListAttributeCallback(), + readThreadNetworkDiagnosticsEventListCommandParams); + result.put( + "readEventListAttribute", readThreadNetworkDiagnosticsEventListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readWiFiNetworkDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readWiFiNetworkDiagnosticsBssidCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBssidAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.BssidAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterBssidAttributeCallback(), + readWiFiNetworkDiagnosticsBssidCommandParams); + result.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readSecurityTypeAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.SecurityTypeAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams); + result.put( + "readSecurityTypeAttribute", + readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readWiFiVersionAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.WiFiVersionAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterWiFiVersionAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams); + result.put( + "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readChannelNumberAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.ChannelNumberAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterChannelNumberAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams); + result.put( + "readChannelNumberAttribute", + readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readRssiAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.RssiAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterRssiAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams); + result.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconLostCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconLostCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterBeaconLostCountAttributeCallback(), + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); + result.put( + "readBeaconLostCountAttribute", + readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconRxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.BeaconRxCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterBeaconRxCountAttributeCallback(), + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); + result.put( + "readBeaconRxCountAttribute", + readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastRxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster + .PacketMulticastRxCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastRxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); + result.put( + "readPacketMulticastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastTxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster + .PacketMulticastTxCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterPacketMulticastTxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); + result.put( + "readPacketMulticastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastRxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster + .PacketUnicastRxCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastRxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); + result.put( + "readPacketUnicastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastTxCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster + .PacketUnicastTxCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterPacketUnicastTxCountAttributeCallback(), + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); + result.put( + "readPacketUnicastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readCurrentMaxRateAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.CurrentMaxRateAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterCurrentMaxRateAttributeCallback(), + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); + result.put( + "readCurrentMaxRateAttribute", + readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readOverrunCountAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.OverrunCountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterOverrunCountAttributeCallback(), + readWiFiNetworkDiagnosticsOverrunCountCommandParams); + result.put( + "readOverrunCountAttribute", + readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readWiFiNetworkDiagnosticsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readWiFiNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readWiFiNetworkDiagnosticsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readWiFiNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readEventListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterEventListAttributeCallback(), + readWiFiNetworkDiagnosticsEventListCommandParams); + result.put( + "readEventListAttribute", readWiFiNetworkDiagnosticsEventListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWiFiNetworkDiagnosticsFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readEthernetNetworkDiagnosticsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readEthernetNetworkDiagnosticsPHYRateCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readPHYRateAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.PHYRateAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterPHYRateAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams); + result.put( + "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readFullDuplexAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.FullDuplexAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterFullDuplexAttributeCallback(), + readEthernetNetworkDiagnosticsFullDuplexCommandParams); + result.put( + "readFullDuplexAttribute", + readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readPacketRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsPacketRxCountCommandParams); + result.put( + "readPacketRxCountAttribute", + readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readPacketTxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsPacketTxCountCommandParams); + result.put( + "readPacketTxCountAttribute", + readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readTxErrCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsTxErrCountCommandParams); + result.put( + "readTxErrCountAttribute", + readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readCollisionCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsCollisionCountCommandParams); + result.put( + "readCollisionCountAttribute", + readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsOverrunCountCommandParams); + result.put( + "readOverrunCountAttribute", + readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readCarrierDetectAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .CarrierDetectAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterCarrierDetectAttributeCallback(), + readEthernetNetworkDiagnosticsCarrierDetectCommandParams); + result.put( + "readCarrierDetectAttribute", + readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readTimeSinceResetAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams); + result.put( + "readTimeSinceResetAttribute", + readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map + readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterGeneratedCommandListAttributeCallback(), + readEthernetNetworkDiagnosticsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readEthernetNetworkDiagnosticsGeneratedCommandListAttributeInteractionInfo); + Map + readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterAcceptedCommandListAttributeCallback(), + readEthernetNetworkDiagnosticsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readEthernetNetworkDiagnosticsAcceptedCommandListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readEventListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterEventListAttributeCallback(), + readEthernetNetworkDiagnosticsEventListCommandParams); + result.put( + "readEventListAttribute", readEthernetNetworkDiagnosticsEventListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readEthernetNetworkDiagnosticsFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readTimeSynchronizationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readTimeSynchronizationUTCTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationUTCTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readUTCTimeAttribute( + (ChipClusters.TimeSynchronizationCluster.UTCTimeAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterUTCTimeAttributeCallback(), + readTimeSynchronizationUTCTimeCommandParams); + result.put("readUTCTimeAttribute", readTimeSynchronizationUTCTimeAttributeInteractionInfo); + Map readTimeSynchronizationGranularityCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationGranularityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readGranularityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationGranularityCommandParams); + result.put( + "readGranularityAttribute", readTimeSynchronizationGranularityAttributeInteractionInfo); + Map readTimeSynchronizationTimeSourceCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeSourceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readTimeSourceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationTimeSourceCommandParams); + result.put( + "readTimeSourceAttribute", readTimeSynchronizationTimeSourceAttributeInteractionInfo); + Map readTimeSynchronizationDefaultNTPCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationDefaultNTPAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readDefaultNTPAttribute( + (ChipClusters.TimeSynchronizationCluster.DefaultNTPAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterDefaultNTPAttributeCallback(), + readTimeSynchronizationDefaultNTPCommandParams); + result.put( + "readDefaultNTPAttribute", readTimeSynchronizationDefaultNTPAttributeInteractionInfo); + Map readTimeSynchronizationTimeZoneCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeZoneAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readTimeZoneAttribute( + (ChipClusters.TimeSynchronizationCluster.TimeZoneAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterTimeZoneAttributeCallback(), + readTimeSynchronizationTimeZoneCommandParams); + result.put("readTimeZoneAttribute", readTimeSynchronizationTimeZoneAttributeInteractionInfo); + Map readTimeSynchronizationDSTOffsetCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationDSTOffsetAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readDSTOffsetAttribute( + (ChipClusters.TimeSynchronizationCluster.DSTOffsetAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterDSTOffsetAttributeCallback(), + readTimeSynchronizationDSTOffsetCommandParams); + result.put("readDSTOffsetAttribute", readTimeSynchronizationDSTOffsetAttributeInteractionInfo); + Map readTimeSynchronizationLocalTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationLocalTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readLocalTimeAttribute( + (ChipClusters.TimeSynchronizationCluster.LocalTimeAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterLocalTimeAttributeCallback(), + readTimeSynchronizationLocalTimeCommandParams); + result.put("readLocalTimeAttribute", readTimeSynchronizationLocalTimeAttributeInteractionInfo); + Map readTimeSynchronizationTimeZoneDatabaseCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readTimeZoneDatabaseAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationTimeZoneDatabaseCommandParams); + result.put( + "readTimeZoneDatabaseAttribute", + readTimeSynchronizationTimeZoneDatabaseAttributeInteractionInfo); + Map readTimeSynchronizationNTPServerAvailableCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readNTPServerAvailableAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readTimeSynchronizationNTPServerAvailableCommandParams); + result.put( + "readNTPServerAvailableAttribute", + readTimeSynchronizationNTPServerAvailableAttributeInteractionInfo); + Map readTimeSynchronizationTimeZoneListMaxSizeCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readTimeZoneListMaxSizeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationTimeZoneListMaxSizeCommandParams); + result.put( + "readTimeZoneListMaxSizeAttribute", + readTimeSynchronizationTimeZoneListMaxSizeAttributeInteractionInfo); + Map readTimeSynchronizationDSTOffsetListMaxSizeCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readDSTOffsetListMaxSizeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationDSTOffsetListMaxSizeCommandParams); + result.put( + "readDSTOffsetListMaxSizeAttribute", + readTimeSynchronizationDSTOffsetListMaxSizeAttributeInteractionInfo); + Map readTimeSynchronizationSupportsDNSResolveCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readSupportsDNSResolveAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readTimeSynchronizationSupportsDNSResolveCommandParams); + result.put( + "readSupportsDNSResolveAttribute", + readTimeSynchronizationSupportsDNSResolveAttributeInteractionInfo); + Map readTimeSynchronizationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.TimeSynchronizationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterGeneratedCommandListAttributeCallback(), + readTimeSynchronizationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readTimeSynchronizationGeneratedCommandListAttributeInteractionInfo); + Map readTimeSynchronizationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.TimeSynchronizationCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterAcceptedCommandListAttributeCallback(), + readTimeSynchronizationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readTimeSynchronizationAcceptedCommandListAttributeInteractionInfo); + Map readTimeSynchronizationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readEventListAttribute( + (ChipClusters.TimeSynchronizationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterEventListAttributeCallback(), + readTimeSynchronizationEventListCommandParams); + result.put("readEventListAttribute", readTimeSynchronizationEventListAttributeInteractionInfo); + Map readTimeSynchronizationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TimeSynchronizationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTimeSynchronizationClusterAttributeListAttributeCallback(), + readTimeSynchronizationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readTimeSynchronizationAttributeListAttributeInteractionInfo); + Map readTimeSynchronizationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTimeSynchronizationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readTimeSynchronizationFeatureMapAttributeInteractionInfo); + Map readTimeSynchronizationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeSynchronizationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeSynchronizationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeSynchronizationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readTimeSynchronizationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBridgedDeviceBasicInformationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBridgedDeviceBasicInformationVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationVendorNameCommandParams); + result.put( + "readVendorNameAttribute", + readBridgedDeviceBasicInformationVendorNameAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationVendorIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicInformationVendorIDCommandParams); + result.put( + "readVendorIDAttribute", readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationProductNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationProductNameCommandParams); + result.put( + "readProductNameAttribute", + readBridgedDeviceBasicInformationProductNameAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationNodeLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationNodeLabelCommandParams); + result.put( + "readNodeLabelAttribute", + readBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationHardwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicInformationHardwareVersionCommandParams); + result.put( + "readHardwareVersionAttribute", + readBridgedDeviceBasicInformationHardwareVersionAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationHardwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationHardwareVersionStringCommandParams); + result.put( + "readHardwareVersionStringAttribute", + readBridgedDeviceBasicInformationHardwareVersionStringAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationSoftwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBridgedDeviceBasicInformationSoftwareVersionCommandParams); + result.put( + "readSoftwareVersionAttribute", + readBridgedDeviceBasicInformationSoftwareVersionAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationSoftwareVersionStringCommandParams); + result.put( + "readSoftwareVersionStringAttribute", + readBridgedDeviceBasicInformationSoftwareVersionStringAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationManufacturingDateCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationManufacturingDateCommandParams); + result.put( + "readManufacturingDateAttribute", + readBridgedDeviceBasicInformationManufacturingDateAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationPartNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationPartNumberCommandParams); + result.put( + "readPartNumberAttribute", + readBridgedDeviceBasicInformationPartNumberAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationProductURLCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationProductURLCommandParams); + result.put( + "readProductURLAttribute", + readBridgedDeviceBasicInformationProductURLAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationProductLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationProductLabelCommandParams); + result.put( + "readProductLabelAttribute", + readBridgedDeviceBasicInformationProductLabelAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationSerialNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationSerialNumberCommandParams); + result.put( + "readSerialNumberAttribute", + readBridgedDeviceBasicInformationSerialNumberAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationReachableCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationReachableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBridgedDeviceBasicInformationReachableCommandParams); + result.put( + "readReachableAttribute", + readBridgedDeviceBasicInformationReachableAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationUniqueIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBridgedDeviceBasicInformationUniqueIDCommandParams); + result.put( + "readUniqueIDAttribute", readBridgedDeviceBasicInformationUniqueIDAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicInformationClusterGeneratedCommandListAttributeCallback(), + readBridgedDeviceBasicInformationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBridgedDeviceBasicInformationGeneratedCommandListAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicInformationClusterAcceptedCommandListAttributeCallback(), + readBridgedDeviceBasicInformationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readBridgedDeviceBasicInformationAcceptedCommandListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readEventListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicInformationClusterEventListAttributeCallback(), + readBridgedDeviceBasicInformationEventListCommandParams); + result.put( + "readEventListAttribute", + readBridgedDeviceBasicInformationEventListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicInformationClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicInformationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readBridgedDeviceBasicInformationAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicInformationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBridgedDeviceBasicInformationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readBridgedDeviceBasicInformationFeatureMapAttributeInteractionInfo); + Map + readBridgedDeviceBasicInformationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicInformationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readBridgedDeviceBasicInformationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readSwitchInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readSwitchNumberOfPositionsCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams); + result.put( + "readNumberOfPositionsAttribute", readSwitchNumberOfPositionsAttributeInteractionInfo); + Map readSwitchCurrentPositionCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchCurrentPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readCurrentPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchCurrentPositionCommandParams); + result.put("readCurrentPositionAttribute", readSwitchCurrentPositionAttributeInteractionInfo); + Map readSwitchMultiPressMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchMultiPressMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readMultiPressMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchMultiPressMaxCommandParams); + result.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.SwitchCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSwitchClusterGeneratedCommandListAttributeCallback(), + readSwitchGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readSwitchGeneratedCommandListAttributeInteractionInfo); + Map readSwitchAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.SwitchCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedSwitchClusterAcceptedCommandListAttributeCallback(), + readSwitchAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readSwitchAcceptedCommandListAttributeInteractionInfo); + Map readSwitchEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readEventListAttribute( + (ChipClusters.SwitchCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedSwitchClusterEventListAttributeCallback(), + readSwitchEventListCommandParams); + result.put("readEventListAttribute", readSwitchEventListAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), + readSwitchAttributeListCommandParams); + result.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); + Map readSwitchFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readSwitchFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readSwitchFeatureMapAttributeInteractionInfo); + Map readSwitchClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readAdministratorCommissioningInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readAdministratorCommissioningWindowStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams); + result.put( + "readWindowStatusAttribute", + readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminFabricIndexAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AdminFabricIndexAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAdminFabricIndexAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams); + result.put( + "readAdminFabricIndexAttribute", + readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminVendorIdAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AdminVendorIdAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAdminVendorIdAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams); + result.put( + "readAdminVendorIdAttribute", + readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map + readAdministratorCommissioningGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.AdministratorCommissioningCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterGeneratedCommandListAttributeCallback(), + readAdministratorCommissioningGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readAdministratorCommissioningGeneratedCommandListAttributeInteractionInfo); + Map + readAdministratorCommissioningAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAcceptedCommandListAttributeCallback(), + readAdministratorCommissioningAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readAdministratorCommissioningAcceptedCommandListAttributeInteractionInfo); + Map readAdministratorCommissioningEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readEventListAttribute( + (ChipClusters.AdministratorCommissioningCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterEventListAttributeCallback(), + readAdministratorCommissioningEventListCommandParams); + result.put( + "readEventListAttribute", readAdministratorCommissioningEventListAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAdministratorCommissioningFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readAdministratorCommissioningFeatureMapAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOperationalCredentialsInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readOperationalCredentialsNOCsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsNOCsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readNOCsAttribute( + (ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterNOCsAttributeCallback(), + readOperationalCredentialsNOCsCommandParams); + result.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readFabricsAttribute( + (ChipClusters.OperationalCredentialsCluster.FabricsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterFabricsAttributeCallback(), + readOperationalCredentialsFabricsCommandParams); + result.put("readFabricsAttribute", readOperationalCredentialsFabricsAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams); + result.put( + "readSupportedFabricsAttribute", + readOperationalCredentialsSupportedFabricsAttributeInteractionInfo); + Map readOperationalCredentialsCommissionedFabricsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readCommissionedFabricsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCommissionedFabricsCommandParams); + result.put( + "readCommissionedFabricsAttribute", + readOperationalCredentialsCommissionedFabricsAttributeInteractionInfo); + Map + readOperationalCredentialsTrustedRootCertificatesCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readTrustedRootCertificatesAttribute( + (ChipClusters.OperationalCredentialsCluster + .TrustedRootCertificatesAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback(), + readOperationalCredentialsTrustedRootCertificatesCommandParams); + result.put( + "readTrustedRootCertificatesAttribute", + readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readCurrentFabricIndexAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams); + result.put( + "readCurrentFabricIndexAttribute", + readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OperationalCredentialsCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterGeneratedCommandListAttributeCallback(), + readOperationalCredentialsGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readOperationalCredentialsGeneratedCommandListAttributeInteractionInfo); + Map readOperationalCredentialsAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OperationalCredentialsCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterAcceptedCommandListAttributeCallback(), + readOperationalCredentialsAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readOperationalCredentialsAcceptedCommandListAttributeInteractionInfo); + Map readOperationalCredentialsEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readEventListAttribute( + (ChipClusters.OperationalCredentialsCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterEventListAttributeCallback(), + readOperationalCredentialsEventListCommandParams); + result.put( + "readEventListAttribute", readOperationalCredentialsEventListAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOperationalCredentialsFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readOperationalCredentialsFeatureMapAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readGroupKeyManagementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readGroupKeyManagementGroupKeyMapCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementGroupKeyMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readGroupKeyMapAttribute( + (ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback(), + readGroupKeyManagementGroupKeyMapCommandParams); + result.put( + "readGroupKeyMapAttribute", readGroupKeyManagementGroupKeyMapAttributeInteractionInfo); + Map readGroupKeyManagementGroupTableCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementGroupTableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readGroupTableAttribute( + (ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterGroupTableAttributeCallback(), + readGroupKeyManagementGroupTableCommandParams); + result.put("readGroupTableAttribute", readGroupKeyManagementGroupTableAttributeInteractionInfo); + Map readGroupKeyManagementMaxGroupsPerFabricCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readMaxGroupsPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementMaxGroupsPerFabricCommandParams); + result.put( + "readMaxGroupsPerFabricAttribute", + readGroupKeyManagementMaxGroupsPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementMaxGroupKeysPerFabricCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readMaxGroupKeysPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementMaxGroupKeysPerFabricCommandParams); + result.put( + "readMaxGroupKeysPerFabricAttribute", + readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.GroupKeyManagementCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterGeneratedCommandListAttributeCallback(), + readGroupKeyManagementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readGroupKeyManagementGeneratedCommandListAttributeInteractionInfo); + Map readGroupKeyManagementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.GroupKeyManagementCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterAcceptedCommandListAttributeCallback(), + readGroupKeyManagementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readGroupKeyManagementAcceptedCommandListAttributeInteractionInfo); + Map readGroupKeyManagementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readEventListAttribute( + (ChipClusters.GroupKeyManagementCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterEventListAttributeCallback(), + readGroupKeyManagementEventListCommandParams); + result.put("readEventListAttribute", readGroupKeyManagementEventListAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readGroupKeyManagementFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readGroupKeyManagementFeatureMapAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readFixedLabelInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readFixedLabelLabelListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readLabelListAttribute( + (ChipClusters.FixedLabelCluster.LabelListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterLabelListAttributeCallback(), + readFixedLabelLabelListCommandParams); + result.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.FixedLabelCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFixedLabelClusterGeneratedCommandListAttributeCallback(), + readFixedLabelGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readFixedLabelGeneratedCommandListAttributeInteractionInfo); + Map readFixedLabelAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.FixedLabelCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFixedLabelClusterAcceptedCommandListAttributeCallback(), + readFixedLabelAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readFixedLabelAcceptedCommandListAttributeInteractionInfo); + Map readFixedLabelEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readEventListAttribute( + (ChipClusters.FixedLabelCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterEventListAttributeCallback(), + readFixedLabelEventListCommandParams); + result.put("readEventListAttribute", readFixedLabelEventListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), + readFixedLabelAttributeListCommandParams); + result.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFixedLabelFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readFixedLabelFeatureMapAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readUserLabelInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readUserLabelLabelListCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelLabelListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readLabelListAttribute( + (ChipClusters.UserLabelCluster.LabelListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterLabelListAttributeCallback(), + readUserLabelLabelListCommandParams); + result.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.UserLabelCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUserLabelClusterGeneratedCommandListAttributeCallback(), + readUserLabelGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readUserLabelGeneratedCommandListAttributeInteractionInfo); + Map readUserLabelAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.UserLabelCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUserLabelClusterAcceptedCommandListAttributeCallback(), + readUserLabelAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readUserLabelAcceptedCommandListAttributeInteractionInfo); + Map readUserLabelEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readEventListAttribute( + (ChipClusters.UserLabelCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterEventListAttributeCallback(), + readUserLabelEventListCommandParams); + result.put("readEventListAttribute", readUserLabelEventListAttributeInteractionInfo); + Map readUserLabelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.UserLabelCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedUserLabelClusterAttributeListAttributeCallback(), + readUserLabelAttributeListCommandParams); + result.put("readAttributeListAttribute", readUserLabelAttributeListAttributeInteractionInfo); + Map readUserLabelFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUserLabelFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readUserLabelFeatureMapAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readProxyConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readProxyConfigurationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyConfigurationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ProxyConfigurationCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyConfigurationClusterGeneratedCommandListAttributeCallback(), + readProxyConfigurationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readProxyConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readProxyConfigurationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyConfigurationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ProxyConfigurationCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyConfigurationClusterAcceptedCommandListAttributeCallback(), + readProxyConfigurationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readProxyConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readProxyConfigurationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyConfigurationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster) + .readEventListAttribute( + (ChipClusters.ProxyConfigurationCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyConfigurationClusterEventListAttributeCallback(), + readProxyConfigurationEventListCommandParams); + result.put("readEventListAttribute", readProxyConfigurationEventListAttributeInteractionInfo); + Map readProxyConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ProxyConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyConfigurationClusterAttributeListAttributeCallback(), + readProxyConfigurationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readProxyConfigurationAttributeListAttributeInteractionInfo); + Map readProxyConfigurationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyConfigurationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readProxyConfigurationFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readProxyConfigurationFeatureMapAttributeInteractionInfo); + Map readProxyConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readProxyConfigurationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readProxyConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readProxyDiscoveryInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readProxyDiscoveryGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ProxyDiscoveryCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyDiscoveryClusterGeneratedCommandListAttributeCallback(), + readProxyDiscoveryGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readProxyDiscoveryGeneratedCommandListAttributeInteractionInfo); + Map readProxyDiscoveryAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ProxyDiscoveryCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyDiscoveryClusterAcceptedCommandListAttributeCallback(), + readProxyDiscoveryAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readProxyDiscoveryAcceptedCommandListAttributeInteractionInfo); + Map readProxyDiscoveryEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyDiscoveryEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster) + .readEventListAttribute( + (ChipClusters.ProxyDiscoveryCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedProxyDiscoveryClusterEventListAttributeCallback(), + readProxyDiscoveryEventListCommandParams); + result.put("readEventListAttribute", readProxyDiscoveryEventListAttributeInteractionInfo); + Map readProxyDiscoveryAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyDiscoveryAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ProxyDiscoveryCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyDiscoveryClusterAttributeListAttributeCallback(), + readProxyDiscoveryAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readProxyDiscoveryAttributeListAttributeInteractionInfo); + Map readProxyDiscoveryFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyDiscoveryFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readProxyDiscoveryFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readProxyDiscoveryFeatureMapAttributeInteractionInfo); + Map readProxyDiscoveryClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyDiscoveryClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyDiscoveryCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readProxyDiscoveryClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readProxyDiscoveryClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readProxyValidInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readProxyValidGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyValidGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ProxyValidCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyValidClusterGeneratedCommandListAttributeCallback(), + readProxyValidGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readProxyValidGeneratedCommandListAttributeInteractionInfo); + Map readProxyValidAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyValidAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ProxyValidCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedProxyValidClusterAcceptedCommandListAttributeCallback(), + readProxyValidAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readProxyValidAcceptedCommandListAttributeInteractionInfo); + Map readProxyValidEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyValidEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster) + .readEventListAttribute( + (ChipClusters.ProxyValidCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedProxyValidClusterEventListAttributeCallback(), + readProxyValidEventListCommandParams); + result.put("readEventListAttribute", readProxyValidEventListAttributeInteractionInfo); + Map readProxyValidAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyValidAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ProxyValidCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedProxyValidClusterAttributeListAttributeCallback(), + readProxyValidAttributeListCommandParams); + result.put("readAttributeListAttribute", readProxyValidAttributeListAttributeInteractionInfo); + Map readProxyValidFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyValidFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readProxyValidFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readProxyValidFeatureMapAttributeInteractionInfo); + Map readProxyValidClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readProxyValidClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ProxyValidCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readProxyValidClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readProxyValidClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBooleanStateInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBooleanStateStateValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readBooleanStateStateValueCommandParams); + result.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BooleanStateCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBooleanStateClusterGeneratedCommandListAttributeCallback(), + readBooleanStateGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBooleanStateGeneratedCommandListAttributeInteractionInfo); + Map readBooleanStateAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BooleanStateCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBooleanStateClusterAcceptedCommandListAttributeCallback(), + readBooleanStateAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readBooleanStateAcceptedCommandListAttributeInteractionInfo); + Map readBooleanStateEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readEventListAttribute( + (ChipClusters.BooleanStateCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterEventListAttributeCallback(), + readBooleanStateEventListCommandParams); + result.put("readEventListAttribute", readBooleanStateEventListAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams); + result.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBooleanStateFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readBooleanStateFeatureMapAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readIcdManagementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readIcdManagementIdleModeIntervalCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementIdleModeIntervalAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readIdleModeIntervalAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementIdleModeIntervalCommandParams); + result.put( + "readIdleModeIntervalAttribute", readIcdManagementIdleModeIntervalAttributeInteractionInfo); + Map readIcdManagementActiveModeIntervalCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementActiveModeIntervalAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readActiveModeIntervalAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementActiveModeIntervalCommandParams); + result.put( + "readActiveModeIntervalAttribute", + readIcdManagementActiveModeIntervalAttributeInteractionInfo); + Map readIcdManagementActiveModeThresholdCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementActiveModeThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readActiveModeThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIcdManagementActiveModeThresholdCommandParams); + result.put( + "readActiveModeThresholdAttribute", + readIcdManagementActiveModeThresholdAttributeInteractionInfo); + Map readIcdManagementRegisteredClientsCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementRegisteredClientsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readRegisteredClientsAttribute( + (ChipClusters.IcdManagementCluster.RegisteredClientsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIcdManagementClusterRegisteredClientsAttributeCallback(), + readIcdManagementRegisteredClientsCommandParams); + result.put( + "readRegisteredClientsAttribute", + readIcdManagementRegisteredClientsAttributeInteractionInfo); + Map readIcdManagementICDCounterCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementICDCounterAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readICDCounterAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementICDCounterCommandParams); + result.put("readICDCounterAttribute", readIcdManagementICDCounterAttributeInteractionInfo); + Map readIcdManagementClientsSupportedPerFabricCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readClientsSupportedPerFabricAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIcdManagementClientsSupportedPerFabricCommandParams); + result.put( + "readClientsSupportedPerFabricAttribute", + readIcdManagementClientsSupportedPerFabricAttributeInteractionInfo); + Map readIcdManagementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.IcdManagementCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIcdManagementClusterGeneratedCommandListAttributeCallback(), + readIcdManagementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readIcdManagementGeneratedCommandListAttributeInteractionInfo); + Map readIcdManagementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.IcdManagementCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIcdManagementClusterAcceptedCommandListAttributeCallback(), + readIcdManagementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readIcdManagementAcceptedCommandListAttributeInteractionInfo); + Map readIcdManagementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readEventListAttribute( + (ChipClusters.IcdManagementCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIcdManagementClusterEventListAttributeCallback(), + readIcdManagementEventListCommandParams); + result.put("readEventListAttribute", readIcdManagementEventListAttributeInteractionInfo); + Map readIcdManagementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IcdManagementCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIcdManagementClusterAttributeListAttributeCallback(), + readIcdManagementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readIcdManagementAttributeListAttributeInteractionInfo); + Map readIcdManagementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIcdManagementFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readIcdManagementFeatureMapAttributeInteractionInfo); + Map readIcdManagementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIcdManagementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IcdManagementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIcdManagementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readIcdManagementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readModeSelectInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readModeSelectDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readModeSelectDescriptionCommandParams); + result.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectStandardNamespaceCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectStandardNamespaceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readStandardNamespaceAttribute( + (ChipClusters.ModeSelectCluster.StandardNamespaceAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedModeSelectClusterStandardNamespaceAttributeCallback(), + readModeSelectStandardNamespaceCommandParams); + result.put( + "readStandardNamespaceAttribute", readModeSelectStandardNamespaceAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readSupportedModesAttribute( + (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams); + result.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectCurrentModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams); + result.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readStartUpModeAttribute( + (ChipClusters.ModeSelectCluster.StartUpModeAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterStartUpModeAttributeCallback(), + readModeSelectStartUpModeCommandParams); + result.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readOnModeAttribute( + (ChipClusters.ModeSelectCluster.OnModeAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterOnModeAttributeCallback(), + readModeSelectOnModeCommandParams); + result.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ModeSelectCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedModeSelectClusterGeneratedCommandListAttributeCallback(), + readModeSelectGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readModeSelectGeneratedCommandListAttributeInteractionInfo); + Map readModeSelectAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ModeSelectCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedModeSelectClusterAcceptedCommandListAttributeCallback(), + readModeSelectAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readModeSelectAcceptedCommandListAttributeInteractionInfo); + Map readModeSelectEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readEventListAttribute( + (ChipClusters.ModeSelectCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterEventListAttributeCallback(), + readModeSelectEventListCommandParams); + result.put("readEventListAttribute", readModeSelectEventListAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), + readModeSelectAttributeListCommandParams); + result.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readModeSelectFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readModeSelectFeatureMapAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readTemperatureControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readTemperatureControlTemperatureSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlTemperatureSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readTemperatureSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlTemperatureSetpointCommandParams); + result.put( + "readTemperatureSetpointAttribute", + readTemperatureControlTemperatureSetpointAttributeInteractionInfo); + Map readTemperatureControlMinTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlMinTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readMinTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlMinTemperatureCommandParams); + result.put( + "readMinTemperatureAttribute", + readTemperatureControlMinTemperatureAttributeInteractionInfo); + Map readTemperatureControlMaxTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlMaxTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readMaxTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlMaxTemperatureCommandParams); + result.put( + "readMaxTemperatureAttribute", + readTemperatureControlMaxTemperatureAttributeInteractionInfo); + Map readTemperatureControlStepCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlStepAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readStepAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlStepCommandParams); + result.put("readStepAttribute", readTemperatureControlStepAttributeInteractionInfo); + Map + readTemperatureControlCurrentTemperatureLevelIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readCurrentTemperatureLevelIndexAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlCurrentTemperatureLevelIndexCommandParams); + result.put( + "readCurrentTemperatureLevelIndexAttribute", + readTemperatureControlCurrentTemperatureLevelIndexAttributeInteractionInfo); + Map + readTemperatureControlSupportedTemperatureLevelsCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readSupportedTemperatureLevelsAttribute( + (ChipClusters.TemperatureControlCluster + .SupportedTemperatureLevelsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureControlClusterSupportedTemperatureLevelsAttributeCallback(), + readTemperatureControlSupportedTemperatureLevelsCommandParams); + result.put( + "readSupportedTemperatureLevelsAttribute", + readTemperatureControlSupportedTemperatureLevelsAttributeInteractionInfo); + Map readTemperatureControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.TemperatureControlCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureControlClusterGeneratedCommandListAttributeCallback(), + readTemperatureControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readTemperatureControlGeneratedCommandListAttributeInteractionInfo); + Map readTemperatureControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.TemperatureControlCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureControlClusterAcceptedCommandListAttributeCallback(), + readTemperatureControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readTemperatureControlAcceptedCommandListAttributeInteractionInfo); + Map readTemperatureControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.TemperatureControlCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureControlClusterEventListAttributeCallback(), + readTemperatureControlEventListCommandParams); + result.put("readEventListAttribute", readTemperatureControlEventListAttributeInteractionInfo); + Map readTemperatureControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TemperatureControlCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureControlClusterAttributeListAttributeCallback(), + readTemperatureControlAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readTemperatureControlAttributeListAttributeInteractionInfo); + Map readTemperatureControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTemperatureControlFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readTemperatureControlFeatureMapAttributeInteractionInfo); + Map readTemperatureControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readTemperatureControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readRefrigeratorAlarmInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readRefrigeratorAlarmMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readMaskAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmMaskCommandParams); + result.put("readMaskAttribute", readRefrigeratorAlarmMaskAttributeInteractionInfo); + Map readRefrigeratorAlarmLatchCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmLatchAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readLatchAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmLatchCommandParams); + result.put("readLatchAttribute", readRefrigeratorAlarmLatchAttributeInteractionInfo); + Map readRefrigeratorAlarmStateCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readStateAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmStateCommandParams); + result.put("readStateAttribute", readRefrigeratorAlarmStateAttributeInteractionInfo); + Map readRefrigeratorAlarmGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRefrigeratorAlarmClusterGeneratedCommandListAttributeCallback(), + readRefrigeratorAlarmGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readRefrigeratorAlarmGeneratedCommandListAttributeInteractionInfo); + Map readRefrigeratorAlarmAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRefrigeratorAlarmClusterAcceptedCommandListAttributeCallback(), + readRefrigeratorAlarmAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readRefrigeratorAlarmAcceptedCommandListAttributeInteractionInfo); + Map readRefrigeratorAlarmEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readEventListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRefrigeratorAlarmClusterEventListAttributeCallback(), + readRefrigeratorAlarmEventListCommandParams); + result.put("readEventListAttribute", readRefrigeratorAlarmEventListAttributeInteractionInfo); + Map readRefrigeratorAlarmAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.RefrigeratorAlarmCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRefrigeratorAlarmClusterAttributeListAttributeCallback(), + readRefrigeratorAlarmAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readRefrigeratorAlarmAttributeListAttributeInteractionInfo); + Map readRefrigeratorAlarmFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRefrigeratorAlarmFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readRefrigeratorAlarmFeatureMapAttributeInteractionInfo); + Map readRefrigeratorAlarmClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRefrigeratorAlarmClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readRefrigeratorAlarmClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readAirQualityInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readAirQualityAirQualityCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityAirQualityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readAirQualityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAirQualityAirQualityCommandParams); + result.put("readAirQualityAttribute", readAirQualityAirQualityAttributeInteractionInfo); + Map readAirQualityGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.AirQualityCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAirQualityClusterGeneratedCommandListAttributeCallback(), + readAirQualityGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readAirQualityGeneratedCommandListAttributeInteractionInfo); + Map readAirQualityAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.AirQualityCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAirQualityClusterAcceptedCommandListAttributeCallback(), + readAirQualityAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readAirQualityAcceptedCommandListAttributeInteractionInfo); + Map readAirQualityEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readEventListAttribute( + (ChipClusters.AirQualityCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAirQualityClusterEventListAttributeCallback(), + readAirQualityEventListCommandParams); + result.put("readEventListAttribute", readAirQualityEventListAttributeInteractionInfo); + Map readAirQualityAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AirQualityCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAirQualityClusterAttributeListAttributeCallback(), + readAirQualityAttributeListCommandParams); + result.put("readAttributeListAttribute", readAirQualityAttributeListAttributeInteractionInfo); + Map readAirQualityFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAirQualityFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readAirQualityFeatureMapAttributeInteractionInfo); + Map readAirQualityClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAirQualityClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AirQualityCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAirQualityClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readAirQualityClusterRevisionAttributeInteractionInfo); + + 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 readDishwasherAlarmInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readDishwasherAlarmMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readMaskAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmMaskCommandParams); + result.put("readMaskAttribute", readDishwasherAlarmMaskAttributeInteractionInfo); + Map readDishwasherAlarmLatchCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmLatchAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readLatchAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmLatchCommandParams); + result.put("readLatchAttribute", readDishwasherAlarmLatchAttributeInteractionInfo); + Map readDishwasherAlarmStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readStateAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmStateCommandParams); + result.put("readStateAttribute", readDishwasherAlarmStateAttributeInteractionInfo); + Map readDishwasherAlarmGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.DishwasherAlarmCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDishwasherAlarmClusterGeneratedCommandListAttributeCallback(), + readDishwasherAlarmGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo); + Map readDishwasherAlarmAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.DishwasherAlarmCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDishwasherAlarmClusterAcceptedCommandListAttributeCallback(), + readDishwasherAlarmAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readDishwasherAlarmAcceptedCommandListAttributeInteractionInfo); + Map readDishwasherAlarmEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readEventListAttribute( + (ChipClusters.DishwasherAlarmCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedDishwasherAlarmClusterEventListAttributeCallback(), + readDishwasherAlarmEventListCommandParams); + result.put("readEventListAttribute", readDishwasherAlarmEventListAttributeInteractionInfo); + Map readDishwasherAlarmAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DishwasherAlarmCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDishwasherAlarmClusterAttributeListAttributeCallback(), + readDishwasherAlarmAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readDishwasherAlarmAttributeListAttributeInteractionInfo); + Map readDishwasherAlarmFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readDishwasherAlarmFeatureMapAttributeInteractionInfo); + Map readDishwasherAlarmClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDishwasherAlarmClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDishwasherAlarmClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readDishwasherAlarmClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readHepaFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readHepaFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringConditionCommandParams); + result.put("readConditionAttribute", readHepaFilterMonitoringConditionAttributeInteractionInfo); + Map readHepaFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readHepaFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readHepaFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readHepaFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readHepaFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readHepaFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readHepaFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readHepaFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.HepaFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedHepaFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readHepaFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readHepaFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readHepaFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.HepaFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedHepaFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readHepaFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readHepaFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readHepaFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.HepaFilterMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedHepaFilterMonitoringClusterEventListAttributeCallback(), + readHepaFilterMonitoringEventListCommandParams); + result.put("readEventListAttribute", readHepaFilterMonitoringEventListAttributeInteractionInfo); + Map readHepaFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.HepaFilterMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedHepaFilterMonitoringClusterAttributeListAttributeCallback(), + readHepaFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readHepaFilterMonitoringAttributeListAttributeInteractionInfo); + Map readHepaFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readHepaFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readHepaFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readHepaFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.HepaFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readHepaFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readHepaFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readActivatedCarbonFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readActivatedCarbonFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", + readActivatedCarbonFilterMonitoringConditionAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo + readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readActivatedCarbonFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readActivatedCarbonFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readActivatedCarbonFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readActivatedCarbonFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo + readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedActivatedCarbonFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readActivatedCarbonFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readActivatedCarbonFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedActivatedCarbonFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readActivatedCarbonFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readActivatedCarbonFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster + .EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedActivatedCarbonFilterMonitoringClusterEventListAttributeCallback(), + readActivatedCarbonFilterMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", + readActivatedCarbonFilterMonitoringEventListAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ActivatedCarbonFilterMonitoringCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedActivatedCarbonFilterMonitoringClusterAttributeListAttributeCallback(), + readActivatedCarbonFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readActivatedCarbonFilterMonitoringAttributeListAttributeInteractionInfo); + Map readActivatedCarbonFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readActivatedCarbonFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readActivatedCarbonFilterMonitoringFeatureMapAttributeInteractionInfo); + Map + readActivatedCarbonFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ActivatedCarbonFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readActivatedCarbonFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readActivatedCarbonFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readCeramicFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readCeramicFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", readCeramicFilterMonitoringConditionAttributeInteractionInfo); + Map readCeramicFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readCeramicFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readCeramicFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readCeramicFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readCeramicFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readCeramicFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readCeramicFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readCeramicFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedCeramicFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readCeramicFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readCeramicFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readCeramicFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedCeramicFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readCeramicFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readCeramicFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readCeramicFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedCeramicFilterMonitoringClusterEventListAttributeCallback(), + readCeramicFilterMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", readCeramicFilterMonitoringEventListAttributeInteractionInfo); + Map readCeramicFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.CeramicFilterMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedCeramicFilterMonitoringClusterAttributeListAttributeCallback(), + readCeramicFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readCeramicFilterMonitoringAttributeListAttributeInteractionInfo); + Map readCeramicFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readCeramicFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readCeramicFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readCeramicFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.CeramicFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readCeramicFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readCeramicFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readElectrostaticFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readElectrostaticFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", + readElectrostaticFilterMonitoringConditionAttributeInteractionInfo); + Map + readElectrostaticFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readElectrostaticFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map + readElectrostaticFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readElectrostaticFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map + readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readElectrostaticFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readElectrostaticFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map + readElectrostaticFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectrostaticFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readElectrostaticFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readElectrostaticFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map + readElectrostaticFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectrostaticFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readElectrostaticFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readElectrostaticFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectrostaticFilterMonitoringClusterEventListAttributeCallback(), + readElectrostaticFilterMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", + readElectrostaticFilterMonitoringEventListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ElectrostaticFilterMonitoringCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectrostaticFilterMonitoringClusterAttributeListAttributeCallback(), + readElectrostaticFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readElectrostaticFilterMonitoringAttributeListAttributeInteractionInfo); + Map readElectrostaticFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectrostaticFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readElectrostaticFilterMonitoringFeatureMapAttributeInteractionInfo); + Map + readElectrostaticFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectrostaticFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectrostaticFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readElectrostaticFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readUvFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readUvFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringConditionCommandParams); + result.put("readConditionAttribute", readUvFilterMonitoringConditionAttributeInteractionInfo); + Map readUvFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readUvFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readUvFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readUvFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readUvFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUvFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readUvFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readUvFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.UvFilterMonitoringCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUvFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readUvFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readUvFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readUvFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.UvFilterMonitoringCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUvFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readUvFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readUvFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readUvFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.UvFilterMonitoringCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUvFilterMonitoringClusterEventListAttributeCallback(), + readUvFilterMonitoringEventListCommandParams); + result.put("readEventListAttribute", readUvFilterMonitoringEventListAttributeInteractionInfo); + Map readUvFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.UvFilterMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUvFilterMonitoringClusterAttributeListAttributeCallback(), + readUvFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readUvFilterMonitoringAttributeListAttributeInteractionInfo); + Map readUvFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUvFilterMonitoringFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readUvFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readUvFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUvFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UvFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUvFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readUvFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readIonizingFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readIonizingFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", readIonizingFilterMonitoringConditionAttributeInteractionInfo); + Map + readIonizingFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readIonizingFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readIonizingFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readIonizingFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readIonizingFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readIonizingFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readIonizingFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map + readIonizingFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIonizingFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readIonizingFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readIonizingFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readIonizingFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIonizingFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readIonizingFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readIonizingFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readIonizingFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIonizingFilterMonitoringClusterEventListAttributeCallback(), + readIonizingFilterMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", readIonizingFilterMonitoringEventListAttributeInteractionInfo); + Map readIonizingFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IonizingFilterMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIonizingFilterMonitoringClusterAttributeListAttributeCallback(), + readIonizingFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readIonizingFilterMonitoringAttributeListAttributeInteractionInfo); + Map readIonizingFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIonizingFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readIonizingFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readIonizingFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IonizingFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIonizingFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readIonizingFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readZeoliteFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readZeoliteFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", readZeoliteFilterMonitoringConditionAttributeInteractionInfo); + Map readZeoliteFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readZeoliteFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readZeoliteFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readZeoliteFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readZeoliteFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readZeoliteFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readZeoliteFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readZeoliteFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedZeoliteFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readZeoliteFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readZeoliteFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedZeoliteFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readZeoliteFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readZeoliteFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedZeoliteFilterMonitoringClusterEventListAttributeCallback(), + readZeoliteFilterMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", readZeoliteFilterMonitoringEventListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ZeoliteFilterMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedZeoliteFilterMonitoringClusterAttributeListAttributeCallback(), + readZeoliteFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readZeoliteFilterMonitoringAttributeListAttributeInteractionInfo); + Map readZeoliteFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readZeoliteFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readZeoliteFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readZeoliteFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ZeoliteFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readZeoliteFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readZeoliteFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOzoneFilterMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readOzoneFilterMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", readOzoneFilterMonitoringConditionAttributeInteractionInfo); + Map readOzoneFilterMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readOzoneFilterMonitoringDegradationDirectionAttributeInteractionInfo); + Map readOzoneFilterMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readOzoneFilterMonitoringChangeIndicationAttributeInteractionInfo); + Map readOzoneFilterMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readOzoneFilterMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readOzoneFilterMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readOzoneFilterMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOzoneFilterMonitoringClusterGeneratedCommandListAttributeCallback(), + readOzoneFilterMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readOzoneFilterMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readOzoneFilterMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOzoneFilterMonitoringClusterAcceptedCommandListAttributeCallback(), + readOzoneFilterMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readOzoneFilterMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readOzoneFilterMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOzoneFilterMonitoringClusterEventListAttributeCallback(), + readOzoneFilterMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", readOzoneFilterMonitoringEventListAttributeInteractionInfo); + Map readOzoneFilterMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OzoneFilterMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOzoneFilterMonitoringClusterAttributeListAttributeCallback(), + readOzoneFilterMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readOzoneFilterMonitoringAttributeListAttributeInteractionInfo); + Map readOzoneFilterMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOzoneFilterMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readOzoneFilterMonitoringFeatureMapAttributeInteractionInfo); + Map readOzoneFilterMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OzoneFilterMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOzoneFilterMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readOzoneFilterMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readWaterTankMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readWaterTankMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringConditionCommandParams); + result.put("readConditionAttribute", readWaterTankMonitoringConditionAttributeInteractionInfo); + Map readWaterTankMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readWaterTankMonitoringDegradationDirectionAttributeInteractionInfo); + Map readWaterTankMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readWaterTankMonitoringChangeIndicationAttributeInteractionInfo); + Map readWaterTankMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readWaterTankMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readWaterTankMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readWaterTankMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.WaterTankMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWaterTankMonitoringClusterGeneratedCommandListAttributeCallback(), + readWaterTankMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readWaterTankMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readWaterTankMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.WaterTankMonitoringCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWaterTankMonitoringClusterAcceptedCommandListAttributeCallback(), + readWaterTankMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readWaterTankMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readWaterTankMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.WaterTankMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWaterTankMonitoringClusterEventListAttributeCallback(), + readWaterTankMonitoringEventListCommandParams); + result.put("readEventListAttribute", readWaterTankMonitoringEventListAttributeInteractionInfo); + Map readWaterTankMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WaterTankMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWaterTankMonitoringClusterAttributeListAttributeCallback(), + readWaterTankMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readWaterTankMonitoringAttributeListAttributeInteractionInfo); + Map readWaterTankMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWaterTankMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readWaterTankMonitoringFeatureMapAttributeInteractionInfo); + Map readWaterTankMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWaterTankMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WaterTankMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWaterTankMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readWaterTankMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readFuelTankMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readFuelTankMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringConditionCommandParams); + result.put("readConditionAttribute", readFuelTankMonitoringConditionAttributeInteractionInfo); + Map readFuelTankMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readFuelTankMonitoringDegradationDirectionAttributeInteractionInfo); + Map readFuelTankMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readFuelTankMonitoringChangeIndicationAttributeInteractionInfo); + Map readFuelTankMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readFuelTankMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readFuelTankMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readFuelTankMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.FuelTankMonitoringCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFuelTankMonitoringClusterGeneratedCommandListAttributeCallback(), + readFuelTankMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readFuelTankMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readFuelTankMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.FuelTankMonitoringCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFuelTankMonitoringClusterAcceptedCommandListAttributeCallback(), + readFuelTankMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readFuelTankMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readFuelTankMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.FuelTankMonitoringCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFuelTankMonitoringClusterEventListAttributeCallback(), + readFuelTankMonitoringEventListCommandParams); + result.put("readEventListAttribute", readFuelTankMonitoringEventListAttributeInteractionInfo); + Map readFuelTankMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FuelTankMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFuelTankMonitoringClusterAttributeListAttributeCallback(), + readFuelTankMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readFuelTankMonitoringAttributeListAttributeInteractionInfo); + Map readFuelTankMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFuelTankMonitoringFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readFuelTankMonitoringFeatureMapAttributeInteractionInfo); + Map readFuelTankMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFuelTankMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FuelTankMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFuelTankMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readFuelTankMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readInkCartridgeMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readInkCartridgeMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", readInkCartridgeMonitoringConditionAttributeInteractionInfo); + Map readInkCartridgeMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readInkCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); + Map readInkCartridgeMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readInkCartridgeMonitoringChangeIndicationAttributeInteractionInfo); + Map readInkCartridgeMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readInkCartridgeMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readInkCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map readInkCartridgeMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedInkCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), + readInkCartridgeMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readInkCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readInkCartridgeMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedInkCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), + readInkCartridgeMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readInkCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readInkCartridgeMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedInkCartridgeMonitoringClusterEventListAttributeCallback(), + readInkCartridgeMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", readInkCartridgeMonitoringEventListAttributeInteractionInfo); + Map readInkCartridgeMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.InkCartridgeMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedInkCartridgeMonitoringClusterAttributeListAttributeCallback(), + readInkCartridgeMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readInkCartridgeMonitoringAttributeListAttributeInteractionInfo); + Map readInkCartridgeMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readInkCartridgeMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readInkCartridgeMonitoringFeatureMapAttributeInteractionInfo); + Map readInkCartridgeMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.InkCartridgeMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readInkCartridgeMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readInkCartridgeMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readTonerCartridgeMonitoringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readTonerCartridgeMonitoringConditionCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringConditionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readConditionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringConditionCommandParams); + result.put( + "readConditionAttribute", readTonerCartridgeMonitoringConditionAttributeInteractionInfo); + Map + readTonerCartridgeMonitoringDegradationDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readDegradationDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringDegradationDirectionCommandParams); + result.put( + "readDegradationDirectionAttribute", + readTonerCartridgeMonitoringDegradationDirectionAttributeInteractionInfo); + Map readTonerCartridgeMonitoringChangeIndicationCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readChangeIndicationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringChangeIndicationCommandParams); + result.put( + "readChangeIndicationAttribute", + readTonerCartridgeMonitoringChangeIndicationAttributeInteractionInfo); + Map readTonerCartridgeMonitoringInPlaceIndicatorCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readInPlaceIndicatorAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readTonerCartridgeMonitoringInPlaceIndicatorCommandParams); + result.put( + "readInPlaceIndicatorAttribute", + readTonerCartridgeMonitoringInPlaceIndicatorAttributeInteractionInfo); + Map + readTonerCartridgeMonitoringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTonerCartridgeMonitoringClusterGeneratedCommandListAttributeCallback(), + readTonerCartridgeMonitoringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readTonerCartridgeMonitoringGeneratedCommandListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTonerCartridgeMonitoringClusterAcceptedCommandListAttributeCallback(), + readTonerCartridgeMonitoringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readTonerCartridgeMonitoringAcceptedCommandListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readEventListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTonerCartridgeMonitoringClusterEventListAttributeCallback(), + readTonerCartridgeMonitoringEventListCommandParams); + result.put( + "readEventListAttribute", readTonerCartridgeMonitoringEventListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TonerCartridgeMonitoringCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTonerCartridgeMonitoringClusterAttributeListAttributeCallback(), + readTonerCartridgeMonitoringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readTonerCartridgeMonitoringAttributeListAttributeInteractionInfo); + Map readTonerCartridgeMonitoringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTonerCartridgeMonitoringFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readTonerCartridgeMonitoringFeatureMapAttributeInteractionInfo); + Map readTonerCartridgeMonitoringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TonerCartridgeMonitoringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTonerCartridgeMonitoringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readTonerCartridgeMonitoringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readDoorLockInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readDoorLockLockStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLockStateAttribute( + (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterLockStateAttributeCallback(), + readDoorLockLockStateCommandParams); + result.put("readLockStateAttribute", readDoorLockLockStateAttributeInteractionInfo); + Map readDoorLockLockTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLockTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLockTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockTypeCommandParams); + result.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); + Map readDoorLockActuatorEnabledCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readActuatorEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockActuatorEnabledCommandParams); + result.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDoorStateAttribute( + (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterDoorStateAttributeCallback(), + readDoorLockDoorStateCommandParams); + result.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockDoorOpenEventsCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDoorOpenEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDoorOpenEventsAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockDoorOpenEventsCommandParams); + result.put("readDoorOpenEventsAttribute", readDoorLockDoorOpenEventsAttributeInteractionInfo); + Map readDoorLockDoorClosedEventsCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDoorClosedEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDoorClosedEventsAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockDoorClosedEventsCommandParams); + result.put( + "readDoorClosedEventsAttribute", readDoorLockDoorClosedEventsAttributeInteractionInfo); + Map readDoorLockOpenPeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockOpenPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readOpenPeriodAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockOpenPeriodCommandParams); + result.put("readOpenPeriodAttribute", readDoorLockOpenPeriodAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfTotalUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams); + result.put( + "readNumberOfTotalUsersSupportedAttribute", + readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo); + Map readDoorLockNumberOfPINUsersSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfPINUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfPINUsersSupportedCommandParams); + result.put( + "readNumberOfPINUsersSupportedAttribute", + readDoorLockNumberOfPINUsersSupportedAttributeInteractionInfo); + Map readDoorLockNumberOfRFIDUsersSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfRFIDUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfRFIDUsersSupportedCommandParams); + result.put( + "readNumberOfRFIDUsersSupportedAttribute", + readDoorLockNumberOfRFIDUsersSupportedAttributeInteractionInfo); + Map + readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfWeekDaySchedulesSupportedPerUserAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfWeekDaySchedulesSupportedPerUserCommandParams); + result.put( + "readNumberOfWeekDaySchedulesSupportedPerUserAttribute", + readDoorLockNumberOfWeekDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map + readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfYearDaySchedulesSupportedPerUserAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfYearDaySchedulesSupportedPerUserCommandParams); + result.put( + "readNumberOfYearDaySchedulesSupportedPerUserAttribute", + readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockNumberOfHolidaySchedulesSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfHolidaySchedulesSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfHolidaySchedulesSupportedCommandParams); + result.put( + "readNumberOfHolidaySchedulesSupportedAttribute", + readDoorLockNumberOfHolidaySchedulesSupportedAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams); + result.put( + "readMaxPINCodeLengthAttribute", readDoorLockMaxPINCodeLengthAttributeInteractionInfo); + Map readDoorLockMinPINCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMinPINCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMinPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMinPINCodeLengthCommandParams); + result.put( + "readMinPINCodeLengthAttribute", readDoorLockMinPINCodeLengthAttributeInteractionInfo); + Map readDoorLockMaxRFIDCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMaxRFIDCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxRFIDCodeLengthCommandParams); + result.put( + "readMaxRFIDCodeLengthAttribute", readDoorLockMaxRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockMinRFIDCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMinRFIDCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMinRFIDCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMinRFIDCodeLengthCommandParams); + result.put( + "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockCredentialRulesSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockCredentialRulesSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readCredentialRulesSupportAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockCredentialRulesSupportCommandParams); + result.put( + "readCredentialRulesSupportAttribute", + readDoorLockCredentialRulesSupportAttributeInteractionInfo); + Map readDoorLockNumberOfCredentialsSupportedPerUserCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfCredentialsSupportedPerUserAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfCredentialsSupportedPerUserCommandParams); + result.put( + "readNumberOfCredentialsSupportedPerUserAttribute", + readDoorLockNumberOfCredentialsSupportedPerUserAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readDoorLockLanguageCommandParams); + result.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockLEDSettingsCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLEDSettingsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLEDSettingsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLEDSettingsCommandParams); + result.put("readLEDSettingsAttribute", readDoorLockLEDSettingsAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockAutoRelockTimeCommandParams); + result.put("readAutoRelockTimeAttribute", readDoorLockAutoRelockTimeAttributeInteractionInfo); + Map readDoorLockSoundVolumeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockSoundVolumeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readSoundVolumeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockSoundVolumeCommandParams); + result.put("readSoundVolumeAttribute", readDoorLockSoundVolumeAttributeInteractionInfo); + Map readDoorLockOperatingModeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockOperatingModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readOperatingModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockOperatingModeCommandParams); + result.put("readOperatingModeAttribute", readDoorLockOperatingModeAttributeInteractionInfo); + Map readDoorLockSupportedOperatingModesCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockSupportedOperatingModesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readSupportedOperatingModesAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockSupportedOperatingModesCommandParams); + result.put( + "readSupportedOperatingModesAttribute", + readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockDefaultConfigurationRegisterCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDefaultConfigurationRegisterAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDefaultConfigurationRegisterCommandParams); + result.put( + "readDefaultConfigurationRegisterAttribute", + readDoorLockDefaultConfigurationRegisterAttributeInteractionInfo); + Map readDoorLockEnableLocalProgrammingCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnableLocalProgrammingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnableLocalProgrammingAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnableLocalProgrammingCommandParams); + result.put( + "readEnableLocalProgrammingAttribute", + readDoorLockEnableLocalProgrammingAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnableOneTouchLockingAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnableOneTouchLockingCommandParams); + result.put( + "readEnableOneTouchLockingAttribute", + readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnableInsideStatusLEDCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnableInsideStatusLEDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnableInsideStatusLEDAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnableInsideStatusLEDCommandParams); + result.put( + "readEnableInsideStatusLEDAttribute", + readDoorLockEnableInsideStatusLEDAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnablePrivacyModeButtonAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockEnablePrivacyModeButtonCommandParams); + result.put( + "readEnablePrivacyModeButtonAttribute", + readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockLocalProgrammingFeaturesCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLocalProgrammingFeaturesAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLocalProgrammingFeaturesCommandParams); + result.put( + "readLocalProgrammingFeaturesAttribute", + readDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readWrongCodeEntryLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams); + result.put( + "readWrongCodeEntryLimitAttribute", + readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockUserCodeTemporaryDisableTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readUserCodeTemporaryDisableTimeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockUserCodeTemporaryDisableTimeCommandParams); + result.put( + "readUserCodeTemporaryDisableTimeAttribute", + readDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); + Map readDoorLockSendPINOverTheAirCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockSendPINOverTheAirAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readSendPINOverTheAirAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockSendPINOverTheAirCommandParams); + result.put( + "readSendPINOverTheAirAttribute", readDoorLockSendPINOverTheAirAttributeInteractionInfo); + Map readDoorLockRequirePINforRemoteOperationCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readRequirePINforRemoteOperationAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readDoorLockRequirePINforRemoteOperationCommandParams); + result.put( + "readRequirePINforRemoteOperationAttribute", + readDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); + Map readDoorLockExpiringUserTimeoutCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockExpiringUserTimeoutAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readExpiringUserTimeoutAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockExpiringUserTimeoutCommandParams); + result.put( + "readExpiringUserTimeoutAttribute", + readDoorLockExpiringUserTimeoutAttributeInteractionInfo); + Map readDoorLockGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.DoorLockCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDoorLockClusterGeneratedCommandListAttributeCallback(), + readDoorLockGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readDoorLockGeneratedCommandListAttributeInteractionInfo); + Map readDoorLockAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.DoorLockCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDoorLockClusterAcceptedCommandListAttributeCallback(), + readDoorLockAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readDoorLockAcceptedCommandListAttributeInteractionInfo); + Map readDoorLockEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEventListAttribute( + (ChipClusters.DoorLockCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterEventListAttributeCallback(), + readDoorLockEventListCommandParams); + result.put("readEventListAttribute", readDoorLockEventListAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), + readDoorLockAttributeListCommandParams); + result.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDoorLockFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readDoorLockFeatureMapAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readWindowCoveringInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readWindowCoveringTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams); + result.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringPhysicalClosedLimitLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readPhysicalClosedLimitLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringPhysicalClosedLimitLiftCommandParams); + result.put( + "readPhysicalClosedLimitLiftAttribute", + readWindowCoveringPhysicalClosedLimitLiftAttributeInteractionInfo); + Map readWindowCoveringPhysicalClosedLimitTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readPhysicalClosedLimitTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringPhysicalClosedLimitTiltCommandParams); + result.put( + "readPhysicalClosedLimitTiltAttribute", + readWindowCoveringPhysicalClosedLimitTiltAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterCurrentPositionLiftAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams); + result.put( + "readCurrentPositionLiftAttribute", + readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterCurrentPositionTiltAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams); + result.put( + "readCurrentPositionTiltAttribute", + readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringNumberOfActuationsLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readNumberOfActuationsLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringNumberOfActuationsLiftCommandParams); + result.put( + "readNumberOfActuationsLiftAttribute", + readWindowCoveringNumberOfActuationsLiftAttributeInteractionInfo); + Map readWindowCoveringNumberOfActuationsTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readNumberOfActuationsTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringNumberOfActuationsTiltCommandParams); + result.put( + "readNumberOfActuationsTiltAttribute", + readWindowCoveringNumberOfActuationsTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams); + result.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercentageAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterCurrentPositionLiftPercentageAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams); + result.put( + "readCurrentPositionLiftPercentageAttribute", + readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercentageAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterCurrentPositionTiltPercentageAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams); + result.put( + "readCurrentPositionTiltPercentageAttribute", + readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo); + Map readWindowCoveringOperationalStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringOperationalStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readOperationalStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringOperationalStatusCommandParams); + result.put( + "readOperationalStatusAttribute", + readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterTargetPositionLiftPercent100thsAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams); + result.put( + "readTargetPositionLiftPercent100thsAttribute", + readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterTargetPositionTiltPercent100thsAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams); + result.put( + "readTargetPositionTiltPercent100thsAttribute", + readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo); + Map readWindowCoveringEndProductTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringEndProductTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readEndProductTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringEndProductTypeCommandParams); + result.put( + "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterCurrentPositionLiftPercent100thsAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); + result.put( + "readCurrentPositionLiftPercent100thsAttribute", + readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterCurrentPositionTiltPercent100thsAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); + result.put( + "readCurrentPositionTiltPercent100thsAttribute", + readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo); + Map readWindowCoveringInstalledOpenLimitLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readInstalledOpenLimitLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledOpenLimitLiftCommandParams); + result.put( + "readInstalledOpenLimitLiftAttribute", + readWindowCoveringInstalledOpenLimitLiftAttributeInteractionInfo); + Map readWindowCoveringInstalledClosedLimitLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readInstalledClosedLimitLiftAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledClosedLimitLiftCommandParams); + result.put( + "readInstalledClosedLimitLiftAttribute", + readWindowCoveringInstalledClosedLimitLiftAttributeInteractionInfo); + Map readWindowCoveringInstalledOpenLimitTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readInstalledOpenLimitTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledOpenLimitTiltCommandParams); + result.put( + "readInstalledOpenLimitTiltAttribute", + readWindowCoveringInstalledOpenLimitTiltAttributeInteractionInfo); + Map readWindowCoveringInstalledClosedLimitTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readInstalledClosedLimitTiltAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringInstalledClosedLimitTiltCommandParams); + result.put( + "readInstalledClosedLimitTiltAttribute", + readWindowCoveringInstalledClosedLimitTiltAttributeInteractionInfo); + Map readWindowCoveringModeCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringModeCommandParams); + result.put("readModeAttribute", readWindowCoveringModeAttributeInteractionInfo); + Map readWindowCoveringSafetyStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringSafetyStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readSafetyStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringSafetyStatusCommandParams); + result.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.WindowCoveringCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterGeneratedCommandListAttributeCallback(), + readWindowCoveringGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readWindowCoveringGeneratedCommandListAttributeInteractionInfo); + Map readWindowCoveringAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.WindowCoveringCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterAcceptedCommandListAttributeCallback(), + readWindowCoveringAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readWindowCoveringAcceptedCommandListAttributeInteractionInfo); + Map readWindowCoveringEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readEventListAttribute( + (ChipClusters.WindowCoveringCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterEventListAttributeCallback(), + readWindowCoveringEventListCommandParams); + result.put("readEventListAttribute", readWindowCoveringEventListAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); + Map readWindowCoveringFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWindowCoveringFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readWindowCoveringFeatureMapAttributeInteractionInfo); + Map readWindowCoveringClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBarrierControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBarrierControlBarrierMovingStateCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierMovingStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams); + result.put( + "readBarrierMovingStateAttribute", + readBarrierControlBarrierMovingStateAttributeInteractionInfo); + Map readBarrierControlBarrierSafetyStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierSafetyStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierSafetyStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierSafetyStatusCommandParams); + result.put( + "readBarrierSafetyStatusAttribute", + readBarrierControlBarrierSafetyStatusAttributeInteractionInfo); + Map readBarrierControlBarrierCapabilitiesCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCapabilitiesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierCapabilitiesAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCapabilitiesCommandParams); + result.put( + "readBarrierCapabilitiesAttribute", + readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierOpenEventsCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierOpenEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierOpenEventsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierOpenEventsCommandParams); + result.put( + "readBarrierOpenEventsAttribute", + readBarrierControlBarrierOpenEventsAttributeInteractionInfo); + Map readBarrierControlBarrierCloseEventsCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCloseEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierCloseEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCloseEventsCommandParams); + result.put( + "readBarrierCloseEventsAttribute", + readBarrierControlBarrierCloseEventsAttributeInteractionInfo); + Map readBarrierControlBarrierCommandOpenEventsCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierCommandOpenEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCommandOpenEventsCommandParams); + result.put( + "readBarrierCommandOpenEventsAttribute", + readBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); + Map readBarrierControlBarrierCommandCloseEventsCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierCommandCloseEventsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierCommandCloseEventsCommandParams); + result.put( + "readBarrierCommandCloseEventsAttribute", + readBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); + Map readBarrierControlBarrierOpenPeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierOpenPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierOpenPeriodAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierOpenPeriodCommandParams); + result.put( + "readBarrierOpenPeriodAttribute", + readBarrierControlBarrierOpenPeriodAttributeInteractionInfo); + Map readBarrierControlBarrierClosePeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierClosePeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierClosePeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierClosePeriodCommandParams); + result.put( + "readBarrierClosePeriodAttribute", + readBarrierControlBarrierClosePeriodAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams); + result.put( + "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BarrierControlCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBarrierControlClusterGeneratedCommandListAttributeCallback(), + readBarrierControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBarrierControlGeneratedCommandListAttributeInteractionInfo); + Map readBarrierControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BarrierControlCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBarrierControlClusterAcceptedCommandListAttributeCallback(), + readBarrierControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readBarrierControlAcceptedCommandListAttributeInteractionInfo); + Map readBarrierControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.BarrierControlCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterEventListAttributeCallback(), + readBarrierControlEventListCommandParams); + result.put("readEventListAttribute", readBarrierControlEventListAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBarrierControlFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readBarrierControlFeatureMapAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readPumpConfigurationAndControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readPumpConfigurationAndControlMaxPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxPressureAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxPressureAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams); + result.put( + "readMaxPressureAttribute", + readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxSpeedAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxSpeedAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams); + result.put( + "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxFlowAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.MaxFlowAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxFlowAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams); + result.put( + "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MinConstPressureAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMinConstPressureAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams); + result.put( + "readMinConstPressureAttribute", + readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MaxConstPressureAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxConstPressureAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams); + result.put( + "readMaxConstPressureAttribute", + readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinCompPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MinCompPressureAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMinCompPressureAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams); + result.put( + "readMinCompPressureAttribute", + readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxCompPressureAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MaxCompPressureAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxCompPressureAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams); + result.put( + "readMaxCompPressureAttribute", + readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MinConstSpeedAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMinConstSpeedAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams); + result.put( + "readMinConstSpeedAttribute", + readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MaxConstSpeedAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxConstSpeedAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams); + result.put( + "readMaxConstSpeedAttribute", + readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstFlowAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MinConstFlowAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMinConstFlowAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams); + result.put( + "readMinConstFlowAttribute", + readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstFlowAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MaxConstFlowAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxConstFlowAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams); + result.put( + "readMaxConstFlowAttribute", + readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstTempAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MinConstTempAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMinConstTempAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams); + result.put( + "readMinConstTempAttribute", + readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstTempAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .MaxConstTempAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterMaxConstTempAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams); + result.put( + "readMaxConstTempAttribute", + readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlPumpStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readPumpStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlPumpStatusCommandParams); + result.put( + "readPumpStatusAttribute", + readPumpConfigurationAndControlPumpStatusAttributeInteractionInfo); + Map + readPumpConfigurationAndControlEffectiveOperationModeCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readEffectiveOperationModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlEffectiveOperationModeCommandParams); + result.put( + "readEffectiveOperationModeAttribute", + readPumpConfigurationAndControlEffectiveOperationModeAttributeInteractionInfo); + Map + readPumpConfigurationAndControlEffectiveControlModeCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readEffectiveControlModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlEffectiveControlModeCommandParams); + result.put( + "readEffectiveControlModeAttribute", + readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readCapacityAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.CapacityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterCapacityAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams); + result.put( + "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readSpeedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.SpeedAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterSpeedAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams); + result.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeRunningHoursAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeRunningHoursAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterLifetimeRunningHoursAttributeCallback(), + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); + result.put( + "readLifetimeRunningHoursAttribute", + readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readPowerAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.PowerAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterPowerAttributeCallback(), + readPumpConfigurationAndControlPowerCommandParams); + result.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeEnergyConsumedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeEnergyConsumedAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterLifetimeEnergyConsumedAttributeCallback(), + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); + result.put( + "readLifetimeEnergyConsumedAttribute", + readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); + Map readPumpConfigurationAndControlOperationModeCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlOperationModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readOperationModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlOperationModeCommandParams); + result.put( + "readOperationModeAttribute", + readPumpConfigurationAndControlOperationModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlControlModeCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlControlModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readControlModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlControlModeCommandParams); + result.put( + "readControlModeAttribute", + readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map + readPumpConfigurationAndControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterGeneratedCommandListAttributeCallback(), + readPumpConfigurationAndControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readPumpConfigurationAndControlGeneratedCommandListAttributeInteractionInfo); + Map + readPumpConfigurationAndControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterAcceptedCommandListAttributeCallback(), + readPumpConfigurationAndControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readPumpConfigurationAndControlAcceptedCommandListAttributeInteractionInfo); + Map readPumpConfigurationAndControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterEventListAttributeCallback(), + readPumpConfigurationAndControlEventListCommandParams); + result.put( + "readEventListAttribute", readPumpConfigurationAndControlEventListAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); + Map readPumpConfigurationAndControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPumpConfigurationAndControlFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo); + Map readPumpConfigurationAndControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readThermostatInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readThermostatLocalTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readLocalTemperatureAttribute( + (ChipClusters.ThermostatCluster.LocalTemperatureAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterLocalTemperatureAttributeCallback(), + readThermostatLocalTemperatureCommandParams); + result.put( + "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatOutdoorTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOutdoorTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOutdoorTemperatureAttribute( + (ChipClusters.ThermostatCluster.OutdoorTemperatureAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterOutdoorTemperatureAttributeCallback(), + readThermostatOutdoorTemperatureCommandParams); + result.put( + "readOutdoorTemperatureAttribute", + readThermostatOutdoorTemperatureAttributeInteractionInfo); + Map readThermostatOccupancyCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupancyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupancyCommandParams); + result.put("readOccupancyAttribute", readThermostatOccupancyAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams); + result.put( + "readAbsMinHeatSetpointLimitAttribute", + readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatAbsMaxHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMaxHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMaxHeatSetpointLimitCommandParams); + result.put( + "readAbsMaxHeatSetpointLimitAttribute", + readThermostatAbsMaxHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatAbsMinCoolSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMinCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinCoolSetpointLimitCommandParams); + result.put( + "readAbsMinCoolSetpointLimitAttribute", + readThermostatAbsMinCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatAbsMaxCoolSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMaxCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMaxCoolSetpointLimitCommandParams); + result.put( + "readAbsMaxCoolSetpointLimitAttribute", + readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatPICoolingDemandCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatPICoolingDemandAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readPICoolingDemandAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatPICoolingDemandCommandParams); + result.put( + "readPICoolingDemandAttribute", readThermostatPICoolingDemandAttributeInteractionInfo); + Map readThermostatPIHeatingDemandCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatPIHeatingDemandAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readPIHeatingDemandAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatPIHeatingDemandCommandParams); + result.put( + "readPIHeatingDemandAttribute", readThermostatPIHeatingDemandAttributeInteractionInfo); + Map readThermostatHVACSystemTypeConfigurationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readHVACSystemTypeConfigurationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatHVACSystemTypeConfigurationCommandParams); + result.put( + "readHVACSystemTypeConfigurationAttribute", + readThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); + Map readThermostatLocalTemperatureCalibrationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureCalibrationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readLocalTemperatureCalibrationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCalibrationCommandParams); + result.put( + "readLocalTemperatureCalibrationAttribute", + readThermostatLocalTemperatureCalibrationAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams); + result.put( + "readOccupiedCoolingSetpointAttribute", + readThermostatOccupiedCoolingSetpointAttributeInteractionInfo); + Map readThermostatOccupiedHeatingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedHeatingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedHeatingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedHeatingSetpointCommandParams); + result.put( + "readOccupiedHeatingSetpointAttribute", + readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatUnoccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readUnoccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUnoccupiedCoolingSetpointCommandParams); + result.put( + "readUnoccupiedCoolingSetpointAttribute", + readThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); + Map readThermostatUnoccupiedHeatingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readUnoccupiedHeatingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUnoccupiedHeatingSetpointCommandParams); + result.put( + "readUnoccupiedHeatingSetpointAttribute", + readThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams); + result.put( + "readMinHeatSetpointLimitAttribute", + readThermostatMinHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatMaxHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMaxHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMaxHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMaxHeatSetpointLimitCommandParams); + result.put( + "readMaxHeatSetpointLimitAttribute", + readThermostatMaxHeatSetpointLimitAttributeInteractionInfo); + Map readThermostatMinCoolSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMinCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMinCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinCoolSetpointLimitCommandParams); + result.put( + "readMinCoolSetpointLimitAttribute", + readThermostatMinCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatMaxCoolSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMaxCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMaxCoolSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMaxCoolSetpointLimitCommandParams); + result.put( + "readMaxCoolSetpointLimitAttribute", + readThermostatMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatMinSetpointDeadBandCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMinSetpointDeadBandAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMinSetpointDeadBandAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinSetpointDeadBandCommandParams); + result.put( + "readMinSetpointDeadBandAttribute", + readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatRemoteSensingCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatRemoteSensingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readRemoteSensingAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatRemoteSensingCommandParams); + result.put("readRemoteSensingAttribute", readThermostatRemoteSensingAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readControlSequenceOfOperationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams); + result.put( + "readControlSequenceOfOperationAttribute", + readThermostatControlSequenceOfOperationAttributeInteractionInfo); + Map readThermostatSystemModeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatSystemModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readSystemModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatSystemModeCommandParams); + result.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatThermostatRunningModeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatThermostatRunningModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readThermostatRunningModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatThermostatRunningModeCommandParams); + result.put( + "readThermostatRunningModeAttribute", + readThermostatThermostatRunningModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams); + result.put("readStartOfWeekAttribute", readThermostatStartOfWeekAttributeInteractionInfo); + Map readThermostatNumberOfWeeklyTransitionsCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readNumberOfWeeklyTransitionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatNumberOfWeeklyTransitionsCommandParams); + result.put( + "readNumberOfWeeklyTransitionsAttribute", + readThermostatNumberOfWeeklyTransitionsAttributeInteractionInfo); + Map readThermostatNumberOfDailyTransitionsCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatNumberOfDailyTransitionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readNumberOfDailyTransitionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatNumberOfDailyTransitionsCommandParams); + result.put( + "readNumberOfDailyTransitionsAttribute", + readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatTemperatureSetpointHoldCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatTemperatureSetpointHoldAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readTemperatureSetpointHoldAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatTemperatureSetpointHoldCommandParams); + result.put( + "readTemperatureSetpointHoldAttribute", + readThermostatTemperatureSetpointHoldAttributeInteractionInfo); + Map readThermostatTemperatureSetpointHoldDurationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readTemperatureSetpointHoldDurationAttribute( + (ChipClusters.ThermostatCluster + .TemperatureSetpointHoldDurationAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterTemperatureSetpointHoldDurationAttributeCallback(), + readThermostatTemperatureSetpointHoldDurationCommandParams); + result.put( + "readTemperatureSetpointHoldDurationAttribute", + readThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); + Map + readThermostatThermostatProgrammingOperationModeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readThermostatProgrammingOperationModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatThermostatProgrammingOperationModeCommandParams); + result.put( + "readThermostatProgrammingOperationModeAttribute", + readThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); + Map readThermostatThermostatRunningStateCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatThermostatRunningStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readThermostatRunningStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatThermostatRunningStateCommandParams); + result.put( + "readThermostatRunningStateAttribute", + readThermostatThermostatRunningStateAttributeInteractionInfo); + Map readThermostatSetpointChangeSourceCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatSetpointChangeSourceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readSetpointChangeSourceAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatSetpointChangeSourceCommandParams); + result.put( + "readSetpointChangeSourceAttribute", + readThermostatSetpointChangeSourceAttributeInteractionInfo); + Map readThermostatSetpointChangeAmountCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatSetpointChangeAmountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readSetpointChangeAmountAttribute( + (ChipClusters.ThermostatCluster.SetpointChangeAmountAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterSetpointChangeAmountAttributeCallback(), + readThermostatSetpointChangeAmountCommandParams); + result.put( + "readSetpointChangeAmountAttribute", + readThermostatSetpointChangeAmountAttributeInteractionInfo); + Map readThermostatSetpointChangeSourceTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readSetpointChangeSourceTimestampAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatSetpointChangeSourceTimestampCommandParams); + result.put( + "readSetpointChangeSourceTimestampAttribute", + readThermostatSetpointChangeSourceTimestampAttributeInteractionInfo); + Map readThermostatOccupiedSetbackCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedSetbackAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedSetbackAttribute( + (ChipClusters.ThermostatCluster.OccupiedSetbackAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedThermostatClusterOccupiedSetbackAttributeCallback(), + readThermostatOccupiedSetbackCommandParams); + result.put( + "readOccupiedSetbackAttribute", readThermostatOccupiedSetbackAttributeInteractionInfo); + Map readThermostatOccupiedSetbackMinCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedSetbackMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedSetbackMinAttribute( + (ChipClusters.ThermostatCluster.OccupiedSetbackMinAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterOccupiedSetbackMinAttributeCallback(), + readThermostatOccupiedSetbackMinCommandParams); + result.put( + "readOccupiedSetbackMinAttribute", + readThermostatOccupiedSetbackMinAttributeInteractionInfo); + Map readThermostatOccupiedSetbackMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedSetbackMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedSetbackMaxAttribute( + (ChipClusters.ThermostatCluster.OccupiedSetbackMaxAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterOccupiedSetbackMaxAttributeCallback(), + readThermostatOccupiedSetbackMaxCommandParams); + result.put( + "readOccupiedSetbackMaxAttribute", + readThermostatOccupiedSetbackMaxAttributeInteractionInfo); + Map readThermostatUnoccupiedSetbackCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedSetbackAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readUnoccupiedSetbackAttribute( + (ChipClusters.ThermostatCluster.UnoccupiedSetbackAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterUnoccupiedSetbackAttributeCallback(), + readThermostatUnoccupiedSetbackCommandParams); + result.put( + "readUnoccupiedSetbackAttribute", readThermostatUnoccupiedSetbackAttributeInteractionInfo); + Map readThermostatUnoccupiedSetbackMinCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedSetbackMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readUnoccupiedSetbackMinAttribute( + (ChipClusters.ThermostatCluster.UnoccupiedSetbackMinAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterUnoccupiedSetbackMinAttributeCallback(), + readThermostatUnoccupiedSetbackMinCommandParams); + result.put( + "readUnoccupiedSetbackMinAttribute", + readThermostatUnoccupiedSetbackMinAttributeInteractionInfo); + Map readThermostatUnoccupiedSetbackMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readUnoccupiedSetbackMaxAttribute( + (ChipClusters.ThermostatCluster.UnoccupiedSetbackMaxAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterUnoccupiedSetbackMaxAttributeCallback(), + readThermostatUnoccupiedSetbackMaxCommandParams); + result.put( + "readUnoccupiedSetbackMaxAttribute", + readThermostatUnoccupiedSetbackMaxAttributeInteractionInfo); + Map readThermostatEmergencyHeatDeltaCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatEmergencyHeatDeltaAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readEmergencyHeatDeltaAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatEmergencyHeatDeltaCommandParams); + result.put( + "readEmergencyHeatDeltaAttribute", + readThermostatEmergencyHeatDeltaAttributeInteractionInfo); + Map readThermostatACTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACTypeCommandParams); + result.put("readACTypeAttribute", readThermostatACTypeAttributeInteractionInfo); + Map readThermostatACCapacityCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACCapacityCommandParams); + result.put("readACCapacityAttribute", readThermostatACCapacityAttributeInteractionInfo); + Map readThermostatACRefrigerantTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACRefrigerantTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACRefrigerantTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACRefrigerantTypeCommandParams); + result.put( + "readACRefrigerantTypeAttribute", readThermostatACRefrigerantTypeAttributeInteractionInfo); + Map readThermostatACCompressorTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACCompressorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACCompressorTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACCompressorTypeCommandParams); + result.put( + "readACCompressorTypeAttribute", readThermostatACCompressorTypeAttributeInteractionInfo); + Map readThermostatACErrorCodeCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACErrorCodeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACErrorCodeAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatACErrorCodeCommandParams); + result.put("readACErrorCodeAttribute", readThermostatACErrorCodeAttributeInteractionInfo); + Map readThermostatACLouverPositionCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACLouverPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACLouverPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACLouverPositionCommandParams); + result.put( + "readACLouverPositionAttribute", readThermostatACLouverPositionAttributeInteractionInfo); + Map readThermostatACCoilTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACCoilTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACCoilTemperatureAttribute( + (ChipClusters.ThermostatCluster.ACCoilTemperatureAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterACCoilTemperatureAttributeCallback(), + readThermostatACCoilTemperatureCommandParams); + result.put( + "readACCoilTemperatureAttribute", readThermostatACCoilTemperatureAttributeInteractionInfo); + Map readThermostatACCapacityformatCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatACCapacityformatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readACCapacityformatAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatACCapacityformatCommandParams); + result.put( + "readACCapacityformatAttribute", readThermostatACCapacityformatAttributeInteractionInfo); + Map readThermostatGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ThermostatCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterGeneratedCommandListAttributeCallback(), + readThermostatGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readThermostatGeneratedCommandListAttributeInteractionInfo); + Map readThermostatAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ThermostatCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatClusterAcceptedCommandListAttributeCallback(), + readThermostatAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readThermostatAcceptedCommandListAttributeInteractionInfo); + Map readThermostatEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readEventListAttribute( + (ChipClusters.ThermostatCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterEventListAttributeCallback(), + readThermostatEventListCommandParams); + result.put("readEventListAttribute", readThermostatEventListAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), + readThermostatAttributeListCommandParams); + result.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); + Map readThermostatFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readThermostatFeatureMapAttributeInteractionInfo); + Map readThermostatClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readFanControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readFanControlFanModeCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlFanModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readFanModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlFanModeCommandParams); + result.put("readFanModeAttribute", readFanControlFanModeAttributeInteractionInfo); + Map readFanControlFanModeSequenceCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlFanModeSequenceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readFanModeSequenceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlFanModeSequenceCommandParams); + result.put( + "readFanModeSequenceAttribute", readFanControlFanModeSequenceAttributeInteractionInfo); + Map readFanControlPercentSettingCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlPercentSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readPercentSettingAttribute( + (ChipClusters.FanControlCluster.PercentSettingAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedFanControlClusterPercentSettingAttributeCallback(), + readFanControlPercentSettingCommandParams); + result.put("readPercentSettingAttribute", readFanControlPercentSettingAttributeInteractionInfo); + Map readFanControlPercentCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlPercentCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readPercentCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlPercentCurrentCommandParams); + result.put("readPercentCurrentAttribute", readFanControlPercentCurrentAttributeInteractionInfo); + Map readFanControlSpeedMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlSpeedMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readSpeedMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlSpeedMaxCommandParams); + result.put("readSpeedMaxAttribute", readFanControlSpeedMaxAttributeInteractionInfo); + Map readFanControlSpeedSettingCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlSpeedSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readSpeedSettingAttribute( + (ChipClusters.FanControlCluster.SpeedSettingAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterSpeedSettingAttributeCallback(), + readFanControlSpeedSettingCommandParams); + result.put("readSpeedSettingAttribute", readFanControlSpeedSettingAttributeInteractionInfo); + Map readFanControlSpeedCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlSpeedCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readSpeedCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlSpeedCurrentCommandParams); + result.put("readSpeedCurrentAttribute", readFanControlSpeedCurrentAttributeInteractionInfo); + Map readFanControlRockSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlRockSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readRockSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlRockSupportCommandParams); + result.put("readRockSupportAttribute", readFanControlRockSupportAttributeInteractionInfo); + Map readFanControlRockSettingCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlRockSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readRockSettingAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlRockSettingCommandParams); + result.put("readRockSettingAttribute", readFanControlRockSettingAttributeInteractionInfo); + Map readFanControlWindSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlWindSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readWindSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlWindSupportCommandParams); + result.put("readWindSupportAttribute", readFanControlWindSupportAttributeInteractionInfo); + Map readFanControlWindSettingCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlWindSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readWindSettingAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlWindSettingCommandParams); + result.put("readWindSettingAttribute", readFanControlWindSettingAttributeInteractionInfo); + Map readFanControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.FanControlCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFanControlClusterGeneratedCommandListAttributeCallback(), + readFanControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readFanControlGeneratedCommandListAttributeInteractionInfo); + Map readFanControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.FanControlCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFanControlClusterAcceptedCommandListAttributeCallback(), + readFanControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readFanControlAcceptedCommandListAttributeInteractionInfo); + Map readFanControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.FanControlCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterEventListAttributeCallback(), + readFanControlEventListCommandParams); + result.put("readEventListAttribute", readFanControlEventListAttributeInteractionInfo); + Map readFanControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FanControlCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFanControlClusterAttributeListAttributeCallback(), + readFanControlAttributeListCommandParams); + result.put("readAttributeListAttribute", readFanControlAttributeListAttributeInteractionInfo); + Map readFanControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFanControlFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readFanControlFeatureMapAttributeInteractionInfo); + Map readFanControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFanControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFanControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readFanControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map + readThermostatUserInterfaceConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readTemperatureDisplayModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); + result.put( + "readTemperatureDisplayModeAttribute", + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readKeypadLockoutAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationKeypadLockoutCommandParams); + result.put( + "readKeypadLockoutAttribute", + readThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readScheduleProgrammingVisibilityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams); + result.put( + "readScheduleProgrammingVisibilityAttribute", + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterGeneratedCommandListAttributeCallback(), + readThermostatUserInterfaceConfigurationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readThermostatUserInterfaceConfigurationGeneratedCommandListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterAcceptedCommandListAttributeCallback(), + readThermostatUserInterfaceConfigurationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readThermostatUserInterfaceConfigurationAcceptedCommandListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readEventListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterEventListAttributeCallback(), + readThermostatUserInterfaceConfigurationEventListCommandParams); + result.put( + "readEventListAttribute", + readThermostatUserInterfaceConfigurationEventListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThermostatUserInterfaceConfigurationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readThermostatUserInterfaceConfigurationFeatureMapAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readColorControlInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readColorControlCurrentHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams); + result.put("readCurrentHueAttribute", readColorControlCurrentHueAttributeInteractionInfo); + Map readColorControlCurrentSaturationCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentSaturationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentSaturationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentSaturationCommandParams); + result.put( + "readCurrentSaturationAttribute", + readColorControlCurrentSaturationAttributeInteractionInfo); + Map readColorControlRemainingTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlRemainingTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readRemainingTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlRemainingTimeCommandParams); + result.put("readRemainingTimeAttribute", readColorControlRemainingTimeAttributeInteractionInfo); + Map readColorControlCurrentXCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentXAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentXCommandParams); + result.put("readCurrentXAttribute", readColorControlCurrentXAttributeInteractionInfo); + Map readColorControlCurrentYCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentYAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentYCommandParams); + result.put("readCurrentYAttribute", readColorControlCurrentYAttributeInteractionInfo); + Map readColorControlDriftCompensationCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlDriftCompensationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readDriftCompensationAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlDriftCompensationCommandParams); + result.put( + "readDriftCompensationAttribute", + readColorControlDriftCompensationAttributeInteractionInfo); + Map readColorControlCompensationTextCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCompensationTextAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readColorControlCompensationTextCommandParams); + result.put( + "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTemperatureMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureMiredsCommandParams); + result.put( + "readColorTemperatureMiredsAttribute", + readColorControlColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams); + result.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlOptionsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readOptionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlOptionsCommandParams); + result.put("readOptionsAttribute", readColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readNumberOfPrimariesAttribute( + (ChipClusters.ColorControlCluster.NumberOfPrimariesAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterNumberOfPrimariesAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams); + result.put( + "readNumberOfPrimariesAttribute", + readColorControlNumberOfPrimariesAttributeInteractionInfo); + Map readColorControlPrimary1XCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary1XAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary1XAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1XCommandParams); + result.put("readPrimary1XAttribute", readColorControlPrimary1XAttributeInteractionInfo); + Map readColorControlPrimary1YCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary1YAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary1YAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1YCommandParams); + result.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary1IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary1IntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterPrimary1IntensityAttributeCallback(), + readColorControlPrimary1IntensityCommandParams); + result.put( + "readPrimary1IntensityAttribute", + readColorControlPrimary1IntensityAttributeInteractionInfo); + Map readColorControlPrimary2XCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary2XAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary2XAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2XCommandParams); + result.put("readPrimary2XAttribute", readColorControlPrimary2XAttributeInteractionInfo); + Map readColorControlPrimary2YCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary2YAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary2YAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2YCommandParams); + result.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary2IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary2IntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterPrimary2IntensityAttributeCallback(), + readColorControlPrimary2IntensityCommandParams); + result.put( + "readPrimary2IntensityAttribute", + readColorControlPrimary2IntensityAttributeInteractionInfo); + Map readColorControlPrimary3XCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary3XAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary3XAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3XCommandParams); + result.put("readPrimary3XAttribute", readColorControlPrimary3XAttributeInteractionInfo); + Map readColorControlPrimary3YCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary3YAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary3YAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3YCommandParams); + result.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary3IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary3IntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterPrimary3IntensityAttributeCallback(), + readColorControlPrimary3IntensityCommandParams); + result.put( + "readPrimary3IntensityAttribute", + readColorControlPrimary3IntensityAttributeInteractionInfo); + Map readColorControlPrimary4XCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary4XAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary4XAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4XCommandParams); + result.put("readPrimary4XAttribute", readColorControlPrimary4XAttributeInteractionInfo); + Map readColorControlPrimary4YCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary4YAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary4YAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4YCommandParams); + result.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary4IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary4IntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterPrimary4IntensityAttributeCallback(), + readColorControlPrimary4IntensityCommandParams); + result.put( + "readPrimary4IntensityAttribute", + readColorControlPrimary4IntensityAttributeInteractionInfo); + Map readColorControlPrimary5XCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary5XAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary5XAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5XCommandParams); + result.put("readPrimary5XAttribute", readColorControlPrimary5XAttributeInteractionInfo); + Map readColorControlPrimary5YCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary5YAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary5YAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5YCommandParams); + result.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary5IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary5IntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterPrimary5IntensityAttributeCallback(), + readColorControlPrimary5IntensityCommandParams); + result.put( + "readPrimary5IntensityAttribute", + readColorControlPrimary5IntensityAttributeInteractionInfo); + Map readColorControlPrimary6XCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary6XAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary6XAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6XCommandParams); + result.put("readPrimary6XAttribute", readColorControlPrimary6XAttributeInteractionInfo); + Map readColorControlPrimary6YCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary6YAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary6YAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6YCommandParams); + result.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary6IntensityAttribute( + (ChipClusters.ColorControlCluster.Primary6IntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterPrimary6IntensityAttributeCallback(), + readColorControlPrimary6IntensityCommandParams); + result.put( + "readPrimary6IntensityAttribute", + readColorControlPrimary6IntensityAttributeInteractionInfo); + Map readColorControlWhitePointXCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlWhitePointXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readWhitePointXAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlWhitePointXCommandParams); + result.put("readWhitePointXAttribute", readColorControlWhitePointXAttributeInteractionInfo); + Map readColorControlWhitePointYCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlWhitePointYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readWhitePointYAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlWhitePointYCommandParams); + result.put("readWhitePointYAttribute", readColorControlWhitePointYAttributeInteractionInfo); + Map readColorControlColorPointRXCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointRXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointRXAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRXCommandParams); + result.put("readColorPointRXAttribute", readColorControlColorPointRXAttributeInteractionInfo); + Map readColorControlColorPointRYCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointRYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointRYAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRYCommandParams); + result.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointRIntensityAttribute( + (ChipClusters.ColorControlCluster.ColorPointRIntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterColorPointRIntensityAttributeCallback(), + readColorControlColorPointRIntensityCommandParams); + result.put( + "readColorPointRIntensityAttribute", + readColorControlColorPointRIntensityAttributeInteractionInfo); + Map readColorControlColorPointGXCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointGXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointGXAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGXCommandParams); + result.put("readColorPointGXAttribute", readColorControlColorPointGXAttributeInteractionInfo); + Map readColorControlColorPointGYCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointGYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointGYAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGYCommandParams); + result.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointGIntensityAttribute( + (ChipClusters.ColorControlCluster.ColorPointGIntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterColorPointGIntensityAttributeCallback(), + readColorControlColorPointGIntensityCommandParams); + result.put( + "readColorPointGIntensityAttribute", + readColorControlColorPointGIntensityAttributeInteractionInfo); + Map readColorControlColorPointBXCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointBXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointBXAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBXCommandParams); + result.put("readColorPointBXAttribute", readColorControlColorPointBXAttributeInteractionInfo); + Map readColorControlColorPointBYCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointBYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointBYAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBYCommandParams); + result.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointBIntensityAttribute( + (ChipClusters.ColorControlCluster.ColorPointBIntensityAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterColorPointBIntensityAttributeCallback(), + readColorControlColorPointBIntensityCommandParams); + result.put( + "readColorPointBIntensityAttribute", + readColorControlColorPointBIntensityAttributeInteractionInfo); + Map readColorControlEnhancedCurrentHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlEnhancedCurrentHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readEnhancedCurrentHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlEnhancedCurrentHueCommandParams); + result.put( + "readEnhancedCurrentHueAttribute", + readColorControlEnhancedCurrentHueAttributeInteractionInfo); + Map readColorControlEnhancedColorModeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlEnhancedColorModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readEnhancedColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlEnhancedColorModeCommandParams); + result.put( + "readEnhancedColorModeAttribute", + readColorControlEnhancedColorModeAttributeInteractionInfo); + Map readColorControlColorLoopActiveCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorLoopActiveAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorLoopActiveAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopActiveCommandParams); + result.put( + "readColorLoopActiveAttribute", readColorControlColorLoopActiveAttributeInteractionInfo); + Map readColorControlColorLoopDirectionCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorLoopDirectionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorLoopDirectionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopDirectionCommandParams); + result.put( + "readColorLoopDirectionAttribute", + readColorControlColorLoopDirectionAttributeInteractionInfo); + Map readColorControlColorLoopTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorLoopTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorLoopTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopTimeCommandParams); + result.put("readColorLoopTimeAttribute", readColorControlColorLoopTimeAttributeInteractionInfo); + Map readColorControlColorLoopStartEnhancedHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorLoopStartEnhancedHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopStartEnhancedHueCommandParams); + result.put( + "readColorLoopStartEnhancedHueAttribute", + readColorControlColorLoopStartEnhancedHueAttributeInteractionInfo); + Map readColorControlColorLoopStoredEnhancedHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorLoopStoredEnhancedHueAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorLoopStoredEnhancedHueCommandParams); + result.put( + "readColorLoopStoredEnhancedHueAttribute", + readColorControlColorLoopStoredEnhancedHueAttributeInteractionInfo); + Map readColorControlColorCapabilitiesCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorCapabilitiesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorCapabilitiesAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorCapabilitiesCommandParams); + result.put( + "readColorCapabilitiesAttribute", + readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinMiredsCommandParams); + result.put( + "readColorTempPhysicalMinMiredsAttribute", + readColorControlColorTempPhysicalMinMiredsAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMaxMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxMiredsCommandParams); + result.put( + "readColorTempPhysicalMaxMiredsAttribute", + readColorControlColorTempPhysicalMaxMiredsAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCoupleColorTempToLevelMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams); + result.put( + "readCoupleColorTempToLevelMinMiredsAttribute", + readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readStartUpColorTemperatureMiredsAttribute( + (ChipClusters.ColorControlCluster + .StartUpColorTemperatureMiredsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterStartUpColorTemperatureMiredsAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams); + result.put( + "readStartUpColorTemperatureMiredsAttribute", + readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ColorControlCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterGeneratedCommandListAttributeCallback(), + readColorControlGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readColorControlGeneratedCommandListAttributeInteractionInfo); + Map readColorControlAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ColorControlCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedColorControlClusterAcceptedCommandListAttributeCallback(), + readColorControlAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readColorControlAcceptedCommandListAttributeInteractionInfo); + Map readColorControlEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readEventListAttribute( + (ChipClusters.ColorControlCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterEventListAttributeCallback(), + readColorControlEventListCommandParams); + result.put("readEventListAttribute", readColorControlEventListAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams); + result.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readColorControlFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readColorControlFeatureMapAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readBallastConfigurationInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readBallastConfigurationPhysicalMinLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readPhysicalMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationPhysicalMinLevelCommandParams); + result.put( + "readPhysicalMinLevelAttribute", + readBallastConfigurationPhysicalMinLevelAttributeInteractionInfo); + Map readBallastConfigurationPhysicalMaxLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readPhysicalMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationPhysicalMaxLevelCommandParams); + result.put( + "readPhysicalMaxLevelAttribute", + readBallastConfigurationPhysicalMaxLevelAttributeInteractionInfo); + Map readBallastConfigurationBallastStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationBallastStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readBallastStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationBallastStatusCommandParams); + result.put( + "readBallastStatusAttribute", + readBallastConfigurationBallastStatusAttributeInteractionInfo); + Map readBallastConfigurationMinLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationMinLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readMinLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationMinLevelCommandParams); + result.put("readMinLevelAttribute", readBallastConfigurationMinLevelAttributeInteractionInfo); + Map readBallastConfigurationMaxLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationMaxLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readMaxLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationMaxLevelCommandParams); + result.put("readMaxLevelAttribute", readBallastConfigurationMaxLevelAttributeInteractionInfo); + Map readBallastConfigurationIntrinsicBallastFactorCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readIntrinsicBallastFactorAttribute( + (ChipClusters.BallastConfigurationCluster + .IntrinsicBallastFactorAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterIntrinsicBallastFactorAttributeCallback(), + readBallastConfigurationIntrinsicBallastFactorCommandParams); + result.put( + "readIntrinsicBallastFactorAttribute", + readBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); + Map readBallastConfigurationBallastFactorAdjustmentCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readBallastFactorAdjustmentAttribute( + (ChipClusters.BallastConfigurationCluster + .BallastFactorAdjustmentAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterBallastFactorAdjustmentAttributeCallback(), + readBallastConfigurationBallastFactorAdjustmentCommandParams); + result.put( + "readBallastFactorAdjustmentAttribute", + readBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); + Map readBallastConfigurationLampQuantityCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampQuantityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampQuantityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationLampQuantityCommandParams); + result.put( + "readLampQuantityAttribute", readBallastConfigurationLampQuantityAttributeInteractionInfo); + Map readBallastConfigurationLampTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampTypeAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBallastConfigurationLampTypeCommandParams); + result.put("readLampTypeAttribute", readBallastConfigurationLampTypeAttributeInteractionInfo); + Map readBallastConfigurationLampManufacturerCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampManufacturerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampManufacturerAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readBallastConfigurationLampManufacturerCommandParams); + result.put( + "readLampManufacturerAttribute", + readBallastConfigurationLampManufacturerAttributeInteractionInfo); + Map readBallastConfigurationLampRatedHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampRatedHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampRatedHoursAttribute( + (ChipClusters.BallastConfigurationCluster.LampRatedHoursAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterLampRatedHoursAttributeCallback(), + readBallastConfigurationLampRatedHoursCommandParams); + result.put( + "readLampRatedHoursAttribute", + readBallastConfigurationLampRatedHoursAttributeInteractionInfo); + Map readBallastConfigurationLampBurnHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampBurnHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampBurnHoursAttribute( + (ChipClusters.BallastConfigurationCluster.LampBurnHoursAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterLampBurnHoursAttributeCallback(), + readBallastConfigurationLampBurnHoursCommandParams); + result.put( + "readLampBurnHoursAttribute", + readBallastConfigurationLampBurnHoursAttributeInteractionInfo); + Map readBallastConfigurationLampAlarmModeCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampAlarmModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampAlarmModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationLampAlarmModeCommandParams); + result.put( + "readLampAlarmModeAttribute", + readBallastConfigurationLampAlarmModeAttributeInteractionInfo); + Map readBallastConfigurationLampBurnHoursTripPointCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readLampBurnHoursTripPointAttribute( + (ChipClusters.BallastConfigurationCluster + .LampBurnHoursTripPointAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterLampBurnHoursTripPointAttributeCallback(), + readBallastConfigurationLampBurnHoursTripPointCommandParams); + result.put( + "readLampBurnHoursTripPointAttribute", + readBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); + Map readBallastConfigurationGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.BallastConfigurationCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterGeneratedCommandListAttributeCallback(), + readBallastConfigurationGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readBallastConfigurationGeneratedCommandListAttributeInteractionInfo); + Map readBallastConfigurationAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.BallastConfigurationCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterAcceptedCommandListAttributeCallback(), + readBallastConfigurationAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readBallastConfigurationAcceptedCommandListAttributeInteractionInfo); + Map readBallastConfigurationEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readEventListAttribute( + (ChipClusters.BallastConfigurationCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterEventListAttributeCallback(), + readBallastConfigurationEventListCommandParams); + result.put("readEventListAttribute", readBallastConfigurationEventListAttributeInteractionInfo); + Map readBallastConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BallastConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBallastConfigurationClusterAttributeListAttributeCallback(), + readBallastConfigurationAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readBallastConfigurationAttributeListAttributeInteractionInfo); + Map readBallastConfigurationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readBallastConfigurationFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readBallastConfigurationFeatureMapAttributeInteractionInfo); + Map readBallastConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBallastConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBallastConfigurationClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readBallastConfigurationClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readIlluminanceMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readIlluminanceMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterMeasuredValueAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams); + result.put( + "readMeasuredValueAttribute", + readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterMinMeasuredValueAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams); + result.put( + "readMinMeasuredValueAttribute", + readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterMaxMeasuredValueAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams); + result.put( + "readMaxMeasuredValueAttribute", + readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementToleranceCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementToleranceCommandParams); + result.put( + "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readLightSensorTypeAttribute( + (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterLightSensorTypeAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams); + result.put( + "readLightSensorTypeAttribute", + readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.IlluminanceMeasurementCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterGeneratedCommandListAttributeCallback(), + readIlluminanceMeasurementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readIlluminanceMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readIlluminanceMeasurementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.IlluminanceMeasurementCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterAcceptedCommandListAttributeCallback(), + readIlluminanceMeasurementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readIlluminanceMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readIlluminanceMeasurementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readEventListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterEventListAttributeCallback(), + readIlluminanceMeasurementEventListCommandParams); + result.put( + "readEventListAttribute", readIlluminanceMeasurementEventListAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readIlluminanceMeasurementFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readIlluminanceMeasurementFeatureMapAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readTemperatureMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readTemperatureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.TemperatureMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterMeasuredValueAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams); + result.put( + "readMeasuredValueAttribute", + readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.TemperatureMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterMinMeasuredValueAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams); + result.put( + "readMinMeasuredValueAttribute", + readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.TemperatureMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterMaxMeasuredValueAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams); + result.put( + "readMaxMeasuredValueAttribute", + readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementToleranceCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementToleranceCommandParams); + result.put( + "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.TemperatureMeasurementCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterGeneratedCommandListAttributeCallback(), + readTemperatureMeasurementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readTemperatureMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readTemperatureMeasurementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.TemperatureMeasurementCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterAcceptedCommandListAttributeCallback(), + readTemperatureMeasurementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readTemperatureMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readTemperatureMeasurementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readEventListAttribute( + (ChipClusters.TemperatureMeasurementCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterEventListAttributeCallback(), + readTemperatureMeasurementEventListCommandParams); + result.put( + "readEventListAttribute", readTemperatureMeasurementEventListAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTemperatureMeasurementFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readTemperatureMeasurementFeatureMapAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readPressureMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readPressureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.PressureMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterMeasuredValueAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams); + result.put( + "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.PressureMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterMinMeasuredValueAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams); + result.put( + "readMinMeasuredValueAttribute", + readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.PressureMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterMaxMeasuredValueAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams); + result.put( + "readMaxMeasuredValueAttribute", + readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementToleranceCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementToleranceCommandParams); + result.put("readToleranceAttribute", readPressureMeasurementToleranceAttributeInteractionInfo); + Map readPressureMeasurementScaledValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementScaledValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readScaledValueAttribute( + (ChipClusters.PressureMeasurementCluster.ScaledValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterScaledValueAttributeCallback(), + readPressureMeasurementScaledValueCommandParams); + result.put( + "readScaledValueAttribute", readPressureMeasurementScaledValueAttributeInteractionInfo); + Map readPressureMeasurementMinScaledValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinScaledValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMinScaledValueAttribute( + (ChipClusters.PressureMeasurementCluster.MinScaledValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterMinScaledValueAttributeCallback(), + readPressureMeasurementMinScaledValueCommandParams); + result.put( + "readMinScaledValueAttribute", + readPressureMeasurementMinScaledValueAttributeInteractionInfo); + Map readPressureMeasurementMaxScaledValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxScaledValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMaxScaledValueAttribute( + (ChipClusters.PressureMeasurementCluster.MaxScaledValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterMaxScaledValueAttributeCallback(), + readPressureMeasurementMaxScaledValueCommandParams); + result.put( + "readMaxScaledValueAttribute", + readPressureMeasurementMaxScaledValueAttributeInteractionInfo); + Map readPressureMeasurementScaledToleranceCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementScaledToleranceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readScaledToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementScaledToleranceCommandParams); + result.put( + "readScaledToleranceAttribute", + readPressureMeasurementScaledToleranceAttributeInteractionInfo); + Map readPressureMeasurementScaleCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementScaleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readScaleAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementScaleCommandParams); + result.put("readScaleAttribute", readPressureMeasurementScaleAttributeInteractionInfo); + Map readPressureMeasurementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.PressureMeasurementCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterGeneratedCommandListAttributeCallback(), + readPressureMeasurementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readPressureMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readPressureMeasurementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.PressureMeasurementCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterAcceptedCommandListAttributeCallback(), + readPressureMeasurementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readPressureMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readPressureMeasurementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readEventListAttribute( + (ChipClusters.PressureMeasurementCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterEventListAttributeCallback(), + readPressureMeasurementEventListCommandParams); + result.put("readEventListAttribute", readPressureMeasurementEventListAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readPressureMeasurementFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readPressureMeasurementFeatureMapAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readPressureMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readFlowMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readFlowMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.FlowMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterMeasuredValueAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams); + result.put( + "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.FlowMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterMinMeasuredValueAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams); + result.put( + "readMinMeasuredValueAttribute", + readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.FlowMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterMaxMeasuredValueAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams); + result.put( + "readMaxMeasuredValueAttribute", + readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementToleranceCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementToleranceCommandParams); + result.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.FlowMeasurementCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterGeneratedCommandListAttributeCallback(), + readFlowMeasurementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readFlowMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readFlowMeasurementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.FlowMeasurementCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterAcceptedCommandListAttributeCallback(), + readFlowMeasurementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readFlowMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readFlowMeasurementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readEventListAttribute( + (ChipClusters.FlowMeasurementCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedFlowMeasurementClusterEventListAttributeCallback(), + readFlowMeasurementEventListCommandParams); + result.put("readEventListAttribute", readFlowMeasurementEventListAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFlowMeasurementFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readFlowMeasurementFeatureMapAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readRelativeHumidityMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readRelativeHumidityMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .MeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterMeasuredValueAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams); + result.put( + "readMeasuredValueAttribute", + readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .MinMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterMinMeasuredValueAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams); + result.put( + "readMinMeasuredValueAttribute", + readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .MaxMeasuredValueAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterMaxMeasuredValueAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); + result.put( + "readMaxMeasuredValueAttribute", + readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementToleranceCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementToleranceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readToleranceAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementToleranceCommandParams); + result.put( + "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map + readRelativeHumidityMeasurementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterGeneratedCommandListAttributeCallback(), + readRelativeHumidityMeasurementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readRelativeHumidityMeasurementGeneratedCommandListAttributeInteractionInfo); + Map + readRelativeHumidityMeasurementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterAcceptedCommandListAttributeCallback(), + readRelativeHumidityMeasurementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readRelativeHumidityMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readEventListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterEventListAttributeCallback(), + readRelativeHumidityMeasurementEventListCommandParams); + result.put( + "readEventListAttribute", readRelativeHumidityMeasurementEventListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readRelativeHumidityMeasurementFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", + readRelativeHumidityMeasurementFeatureMapAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readOccupancySensingInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readOccupancySensingOccupancyCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams); + result.put("readOccupancyAttribute", readOccupancySensingOccupancyAttributeInteractionInfo); + Map readOccupancySensingOccupancySensorTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancySensorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readOccupancySensorTypeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancySensorTypeCommandParams); + result.put( + "readOccupancySensorTypeAttribute", + readOccupancySensingOccupancySensorTypeAttributeInteractionInfo); + Map readOccupancySensingOccupancySensorTypeBitmapCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readOccupancySensorTypeBitmapAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancySensorTypeBitmapCommandParams); + result.put( + "readOccupancySensorTypeBitmapAttribute", + readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map + readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readPIROccupiedToUnoccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams); + result.put( + "readPIROccupiedToUnoccupiedDelayAttribute", + readOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map + readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readPIRUnoccupiedToOccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams); + result.put( + "readPIRUnoccupiedToOccupiedDelayAttribute", + readOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map + readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readPIRUnoccupiedToOccupiedThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams); + result.put( + "readPIRUnoccupiedToOccupiedThresholdAttribute", + readOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map + readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = + new LinkedHashMap(); + InteractionInfo + readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readUltrasonicOccupiedToUnoccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams); + result.put( + "readUltrasonicOccupiedToUnoccupiedDelayAttribute", + readOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map + readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = + new LinkedHashMap(); + InteractionInfo + readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readUltrasonicUnoccupiedToOccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams); + result.put( + "readUltrasonicUnoccupiedToOccupiedDelayAttribute", + readOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map + readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = + new LinkedHashMap(); + InteractionInfo + readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readUltrasonicUnoccupiedToOccupiedThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams); + result.put( + "readUltrasonicUnoccupiedToOccupiedThresholdAttribute", + readOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map + readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = + new LinkedHashMap(); + InteractionInfo + readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readPhysicalContactOccupiedToUnoccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams); + result.put( + "readPhysicalContactOccupiedToUnoccupiedDelayAttribute", + readOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map + readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = + new LinkedHashMap(); + InteractionInfo + readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readPhysicalContactUnoccupiedToOccupiedDelayAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams); + result.put( + "readPhysicalContactUnoccupiedToOccupiedDelayAttribute", + readOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map + readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = + new LinkedHashMap(); + InteractionInfo + readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readPhysicalContactUnoccupiedToOccupiedThresholdAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams); + result.put( + "readPhysicalContactUnoccupiedToOccupiedThresholdAttribute", + readOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map readOccupancySensingGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.OccupancySensingCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOccupancySensingClusterGeneratedCommandListAttributeCallback(), + readOccupancySensingGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readOccupancySensingGeneratedCommandListAttributeInteractionInfo); + Map readOccupancySensingAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.OccupancySensingCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOccupancySensingClusterAcceptedCommandListAttributeCallback(), + readOccupancySensingAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readOccupancySensingAcceptedCommandListAttributeInteractionInfo); + Map readOccupancySensingEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readEventListAttribute( + (ChipClusters.OccupancySensingCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedOccupancySensingClusterEventListAttributeCallback(), + readOccupancySensingEventListCommandParams); + result.put("readEventListAttribute", readOccupancySensingEventListAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readOccupancySensingFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readOccupancySensingFeatureMapAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readOccupancySensingClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readWakeOnLanInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readWakeOnLanMACAddressCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanMACAddressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readMACAddressAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readWakeOnLanMACAddressCommandParams); + result.put("readMACAddressAttribute", readWakeOnLanMACAddressAttributeInteractionInfo); + Map readWakeOnLanGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.WakeOnLanCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWakeOnLanClusterGeneratedCommandListAttributeCallback(), + readWakeOnLanGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readWakeOnLanGeneratedCommandListAttributeInteractionInfo); + Map readWakeOnLanAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.WakeOnLanCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWakeOnLanClusterAcceptedCommandListAttributeCallback(), + readWakeOnLanAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readWakeOnLanAcceptedCommandListAttributeInteractionInfo); + Map readWakeOnLanEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readEventListAttribute( + (ChipClusters.WakeOnLanCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterEventListAttributeCallback(), + readWakeOnLanEventListCommandParams); + result.put("readEventListAttribute", readWakeOnLanEventListAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), + readWakeOnLanAttributeListCommandParams); + result.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readWakeOnLanFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readWakeOnLanFeatureMapAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readChannelInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readChannelChannelListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelChannelListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readChannelListAttribute( + (ChipClusters.ChannelCluster.ChannelListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterChannelListAttributeCallback(), + readChannelChannelListCommandParams); + result.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ChannelCluster.GeneratedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedChannelClusterGeneratedCommandListAttributeCallback(), + readChannelGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readChannelGeneratedCommandListAttributeInteractionInfo); + Map readChannelAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ChannelCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedChannelClusterAcceptedCommandListAttributeCallback(), + readChannelAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", readChannelAcceptedCommandListAttributeInteractionInfo); + Map readChannelEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readEventListAttribute( + (ChipClusters.ChannelCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterEventListAttributeCallback(), + readChannelEventListCommandParams); + result.put("readEventListAttribute", readChannelEventListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), + readChannelAttributeListCommandParams); + result.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readChannelFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readChannelFeatureMapAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readTargetNavigatorInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readTargetNavigatorTargetListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readTargetListAttribute( + (ChipClusters.TargetNavigatorCluster.TargetListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetListAttributeCallback(), + readTargetNavigatorTargetListCommandParams); + result.put("readTargetListAttribute", readTargetNavigatorTargetListAttributeInteractionInfo); + Map readTargetNavigatorCurrentTargetCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentTargetAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readCurrentTargetAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentTargetCommandParams); + result.put( + "readCurrentTargetAttribute", readTargetNavigatorCurrentTargetAttributeInteractionInfo); + Map readTargetNavigatorGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.TargetNavigatorCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterGeneratedCommandListAttributeCallback(), + readTargetNavigatorGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readTargetNavigatorGeneratedCommandListAttributeInteractionInfo); + Map readTargetNavigatorAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.TargetNavigatorCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterAcceptedCommandListAttributeCallback(), + readTargetNavigatorAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readTargetNavigatorAcceptedCommandListAttributeInteractionInfo); + Map readTargetNavigatorEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readEventListAttribute( + (ChipClusters.TargetNavigatorCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedTargetNavigatorClusterEventListAttributeCallback(), + readTargetNavigatorEventListCommandParams); + result.put("readEventListAttribute", readTargetNavigatorEventListAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readTargetNavigatorFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readTargetNavigatorFeatureMapAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readMediaPlaybackInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readMediaPlaybackCurrentStateCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackCurrentStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readCurrentStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackCurrentStateCommandParams); + result.put("readCurrentStateAttribute", readMediaPlaybackCurrentStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readStartTimeAttribute( + (ChipClusters.MediaPlaybackCluster.StartTimeAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterStartTimeAttributeCallback(), + readMediaPlaybackStartTimeCommandParams); + result.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readDurationAttribute( + (ChipClusters.MediaPlaybackCluster.DurationAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterDurationAttributeCallback(), + readMediaPlaybackDurationCommandParams); + result.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); + Map readMediaPlaybackPlaybackSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readPlaybackSpeedAttribute((ChipClusters.FloatAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readMediaPlaybackPlaybackSpeedCommandParams); + result.put( + "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeEndAttribute( + (ChipClusters.MediaPlaybackCluster.SeekRangeEndAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedMediaPlaybackClusterSeekRangeEndAttributeCallback(), + readMediaPlaybackSeekRangeEndCommandParams); + result.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeStartAttribute( + (ChipClusters.MediaPlaybackCluster.SeekRangeStartAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterSeekRangeStartAttributeCallback(), + readMediaPlaybackSeekRangeStartCommandParams); + result.put( + "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.MediaPlaybackCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterGeneratedCommandListAttributeCallback(), + readMediaPlaybackGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readMediaPlaybackGeneratedCommandListAttributeInteractionInfo); + Map readMediaPlaybackAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.MediaPlaybackCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterAcceptedCommandListAttributeCallback(), + readMediaPlaybackAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readMediaPlaybackAcceptedCommandListAttributeInteractionInfo); + Map readMediaPlaybackEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readEventListAttribute( + (ChipClusters.MediaPlaybackCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterEventListAttributeCallback(), + readMediaPlaybackEventListCommandParams); + result.put("readEventListAttribute", readMediaPlaybackEventListAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readMediaPlaybackFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readMediaPlaybackFeatureMapAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readMediaInputInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readMediaInputInputListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputInputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readInputListAttribute( + (ChipClusters.MediaInputCluster.InputListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterInputListAttributeCallback(), + readMediaInputInputListCommandParams); + result.put("readInputListAttribute", readMediaInputInputListAttributeInteractionInfo); + Map readMediaInputCurrentInputCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputCurrentInputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readCurrentInputAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentInputCommandParams); + result.put("readCurrentInputAttribute", readMediaInputCurrentInputAttributeInteractionInfo); + Map readMediaInputGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.MediaInputCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaInputClusterGeneratedCommandListAttributeCallback(), + readMediaInputGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readMediaInputGeneratedCommandListAttributeInteractionInfo); + Map readMediaInputAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.MediaInputCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaInputClusterAcceptedCommandListAttributeCallback(), + readMediaInputAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readMediaInputAcceptedCommandListAttributeInteractionInfo); + Map readMediaInputEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readEventListAttribute( + (ChipClusters.MediaInputCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterEventListAttributeCallback(), + readMediaInputEventListCommandParams); + result.put("readEventListAttribute", readMediaInputEventListAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), + readMediaInputAttributeListCommandParams); + result.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readMediaInputFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readMediaInputFeatureMapAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readLowPowerInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readLowPowerGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.LowPowerCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLowPowerClusterGeneratedCommandListAttributeCallback(), + readLowPowerGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readLowPowerGeneratedCommandListAttributeInteractionInfo); + Map readLowPowerAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.LowPowerCluster.AcceptedCommandListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedLowPowerClusterAcceptedCommandListAttributeCallback(), + readLowPowerAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readLowPowerAcceptedCommandListAttributeInteractionInfo); + Map readLowPowerEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readEventListAttribute( + (ChipClusters.LowPowerCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLowPowerClusterEventListAttributeCallback(), + readLowPowerEventListCommandParams); + result.put("readEventListAttribute", readLowPowerEventListAttributeInteractionInfo); + Map readLowPowerAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), + readLowPowerAttributeListCommandParams); + result.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readLowPowerFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readLowPowerFeatureMapAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams); + result.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readKeypadInputInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readKeypadInputGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.KeypadInputCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedKeypadInputClusterGeneratedCommandListAttributeCallback(), + readKeypadInputGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readKeypadInputGeneratedCommandListAttributeInteractionInfo); + Map readKeypadInputAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.KeypadInputCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedKeypadInputClusterAcceptedCommandListAttributeCallback(), + readKeypadInputAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readKeypadInputAcceptedCommandListAttributeInteractionInfo); + Map readKeypadInputEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readEventListAttribute( + (ChipClusters.KeypadInputCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterEventListAttributeCallback(), + readKeypadInputEventListCommandParams); + result.put("readEventListAttribute", readKeypadInputEventListAttributeInteractionInfo); + Map readKeypadInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams); + result.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readKeypadInputFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readKeypadInputFeatureMapAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readContentLauncherInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readContentLauncherAcceptHeaderCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAcceptHeaderAttribute( + (ChipClusters.ContentLauncherCluster.AcceptHeaderAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAcceptHeaderAttributeCallback(), + readContentLauncherAcceptHeaderCommandParams); + result.put( + "readAcceptHeaderAttribute", readContentLauncherAcceptHeaderAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readSupportedStreamingProtocolsAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readContentLauncherSupportedStreamingProtocolsCommandParams); + result.put( + "readSupportedStreamingProtocolsAttribute", + readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ContentLauncherCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterGeneratedCommandListAttributeCallback(), + readContentLauncherGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readContentLauncherGeneratedCommandListAttributeInteractionInfo); + Map readContentLauncherAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ContentLauncherCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAcceptedCommandListAttributeCallback(), + readContentLauncherAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readContentLauncherAcceptedCommandListAttributeInteractionInfo); + Map readContentLauncherEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readEventListAttribute( + (ChipClusters.ContentLauncherCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedContentLauncherClusterEventListAttributeCallback(), + readContentLauncherEventListCommandParams); + result.put("readEventListAttribute", readContentLauncherEventListAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readContentLauncherFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readContentLauncherFeatureMapAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readAudioOutputInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readAudioOutputOutputListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputOutputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readOutputListAttribute( + (ChipClusters.AudioOutputCluster.OutputListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterOutputListAttributeCallback(), + readAudioOutputOutputListCommandParams); + result.put("readOutputListAttribute", readAudioOutputOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentOutputCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentOutputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readCurrentOutputAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentOutputCommandParams); + result.put("readCurrentOutputAttribute", readAudioOutputCurrentOutputAttributeInteractionInfo); + Map readAudioOutputGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.AudioOutputCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAudioOutputClusterGeneratedCommandListAttributeCallback(), + readAudioOutputGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readAudioOutputGeneratedCommandListAttributeInteractionInfo); + Map readAudioOutputAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.AudioOutputCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAudioOutputClusterAcceptedCommandListAttributeCallback(), + readAudioOutputAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readAudioOutputAcceptedCommandListAttributeInteractionInfo); + Map readAudioOutputEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readEventListAttribute( + (ChipClusters.AudioOutputCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterEventListAttributeCallback(), + readAudioOutputEventListCommandParams); + result.put("readEventListAttribute", readAudioOutputEventListAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams); + result.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAudioOutputFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readAudioOutputFeatureMapAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readApplicationLauncherInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readApplicationLauncherCatalogListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherCatalogListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readCatalogListAttribute( + (ChipClusters.ApplicationLauncherCluster.CatalogListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterCatalogListAttributeCallback(), + readApplicationLauncherCatalogListCommandParams); + result.put( + "readCatalogListAttribute", readApplicationLauncherCatalogListAttributeInteractionInfo); + Map readApplicationLauncherGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ApplicationLauncherCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterGeneratedCommandListAttributeCallback(), + readApplicationLauncherGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readApplicationLauncherGeneratedCommandListAttributeInteractionInfo); + Map readApplicationLauncherAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ApplicationLauncherCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterAcceptedCommandListAttributeCallback(), + readApplicationLauncherAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readApplicationLauncherAcceptedCommandListAttributeInteractionInfo); + Map readApplicationLauncherEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readEventListAttribute( + (ChipClusters.ApplicationLauncherCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterEventListAttributeCallback(), + readApplicationLauncherEventListCommandParams); + result.put("readEventListAttribute", readApplicationLauncherEventListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readApplicationLauncherFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readApplicationLauncherFeatureMapAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readApplicationLauncherClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readApplicationBasicInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readApplicationBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readApplicationBasicVendorNameCommandParams); + result.put("readVendorNameAttribute", readApplicationBasicVendorNameAttributeInteractionInfo); + Map readApplicationBasicVendorIDCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicVendorIDCommandParams); + result.put("readVendorIDAttribute", readApplicationBasicVendorIDAttributeInteractionInfo); + Map readApplicationBasicApplicationNameCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationNameAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readApplicationBasicApplicationNameCommandParams); + result.put( + "readApplicationNameAttribute", + readApplicationBasicApplicationNameAttributeInteractionInfo); + Map readApplicationBasicProductIDCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicProductIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicProductIDCommandParams); + result.put("readProductIDAttribute", readApplicationBasicProductIDAttributeInteractionInfo); + Map readApplicationBasicStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicStatusCommandParams); + result.put("readStatusAttribute", readApplicationBasicStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationVersionAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readApplicationBasicApplicationVersionCommandParams); + result.put( + "readApplicationVersionAttribute", + readApplicationBasicApplicationVersionAttributeInteractionInfo); + Map readApplicationBasicAllowedVendorListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicAllowedVendorListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readAllowedVendorListAttribute( + (ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback(), + readApplicationBasicAllowedVendorListCommandParams); + result.put( + "readAllowedVendorListAttribute", + readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ApplicationBasicCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterGeneratedCommandListAttributeCallback(), + readApplicationBasicGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readApplicationBasicGeneratedCommandListAttributeInteractionInfo); + Map readApplicationBasicAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ApplicationBasicCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterAcceptedCommandListAttributeCallback(), + readApplicationBasicAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readApplicationBasicAcceptedCommandListAttributeInteractionInfo); + Map readApplicationBasicEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readEventListAttribute( + (ChipClusters.ApplicationBasicCluster.EventListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedApplicationBasicClusterEventListAttributeCallback(), + readApplicationBasicEventListCommandParams); + result.put("readEventListAttribute", readApplicationBasicEventListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readApplicationBasicFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readApplicationBasicFeatureMapAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readApplicationBasicClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readAccountLoginInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readAccountLoginGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.AccountLoginCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccountLoginClusterGeneratedCommandListAttributeCallback(), + readAccountLoginGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readAccountLoginGeneratedCommandListAttributeInteractionInfo); + Map readAccountLoginAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.AccountLoginCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccountLoginClusterAcceptedCommandListAttributeCallback(), + readAccountLoginAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readAccountLoginAcceptedCommandListAttributeInteractionInfo); + Map readAccountLoginEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readEventListAttribute( + (ChipClusters.AccountLoginCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterEventListAttributeCallback(), + readAccountLoginEventListCommandParams); + result.put("readEventListAttribute", readAccountLoginEventListAttributeInteractionInfo); + Map readAccountLoginAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams); + result.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readAccountLoginFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readAccountLoginFeatureMapAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readElectricalMeasurementInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readElectricalMeasurementMeasurementTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementMeasurementTypeCommandParams); + result.put( + "readMeasurementTypeAttribute", + readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageCommandParams); + result.put( + "readDcVoltageAttribute", readElectricalMeasurementDcVoltageAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcVoltageMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageMinCommandParams); + result.put( + "readDcVoltageMinAttribute", readElectricalMeasurementDcVoltageMinAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcVoltageMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageMaxCommandParams); + result.put( + "readDcVoltageMaxAttribute", readElectricalMeasurementDcVoltageMaxAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentCommandParams); + result.put( + "readDcCurrentAttribute", readElectricalMeasurementDcCurrentAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcCurrentMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentMinCommandParams); + result.put( + "readDcCurrentMinAttribute", readElectricalMeasurementDcCurrentMinAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcCurrentMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentMaxCommandParams); + result.put( + "readDcCurrentMaxAttribute", readElectricalMeasurementDcCurrentMaxAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcPowerAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerCommandParams); + result.put("readDcPowerAttribute", readElectricalMeasurementDcPowerAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcPowerMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerMinCommandParams); + result.put( + "readDcPowerMinAttribute", readElectricalMeasurementDcPowerMinAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcPowerMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerMaxCommandParams); + result.put( + "readDcPowerMaxAttribute", readElectricalMeasurementDcPowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcVoltageMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageMultiplierCommandParams); + result.put( + "readDcVoltageMultiplierAttribute", + readElectricalMeasurementDcVoltageMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementDcVoltageDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcVoltageDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcVoltageDivisorCommandParams); + result.put( + "readDcVoltageDivisorAttribute", + readElectricalMeasurementDcVoltageDivisorAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentMultiplierCommandParams); + result.put( + "readDcCurrentMultiplierAttribute", + readElectricalMeasurementDcCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementDcCurrentDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcCurrentDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcCurrentDivisorCommandParams); + result.put( + "readDcCurrentDivisorAttribute", + readElectricalMeasurementDcCurrentDivisorAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcPowerMultiplierAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerMultiplierCommandParams); + result.put( + "readDcPowerMultiplierAttribute", + readElectricalMeasurementDcPowerMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementDcPowerDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readDcPowerDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementDcPowerDivisorCommandParams); + result.put( + "readDcPowerDivisorAttribute", + readElectricalMeasurementDcPowerDivisorAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcFrequencyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyCommandParams); + result.put( + "readAcFrequencyAttribute", readElectricalMeasurementAcFrequencyAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcFrequencyMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyMinCommandParams); + result.put( + "readAcFrequencyMinAttribute", + readElectricalMeasurementAcFrequencyMinAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcFrequencyMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyMaxCommandParams); + result.put( + "readAcFrequencyMaxAttribute", + readElectricalMeasurementAcFrequencyMaxAttributeInteractionInfo); + Map readElectricalMeasurementNeutralCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementNeutralCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readNeutralCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementNeutralCurrentCommandParams); + result.put( + "readNeutralCurrentAttribute", + readElectricalMeasurementNeutralCurrentAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementTotalActivePowerCommandParams); + result.put( + "readTotalActivePowerAttribute", + readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementTotalReactivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readTotalReactivePowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementTotalReactivePowerCommandParams); + result.put( + "readTotalReactivePowerAttribute", + readElectricalMeasurementTotalReactivePowerAttributeInteractionInfo); + Map readElectricalMeasurementTotalApparentPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readTotalApparentPowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementTotalApparentPowerCommandParams); + result.put( + "readTotalApparentPowerAttribute", + readElectricalMeasurementTotalApparentPowerAttributeInteractionInfo); + Map + readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasured1stHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured1stHarmonicCurrentCommandParams); + result.put( + "readMeasured1stHarmonicCurrentAttribute", + readElectricalMeasurementMeasured1stHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasured3rdHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured3rdHarmonicCurrentCommandParams); + result.put( + "readMeasured3rdHarmonicCurrentAttribute", + readElectricalMeasurementMeasured3rdHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasured5thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured5thHarmonicCurrentCommandParams); + result.put( + "readMeasured5thHarmonicCurrentAttribute", + readElectricalMeasurementMeasured5thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasured7thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured7thHarmonicCurrentCommandParams); + result.put( + "readMeasured7thHarmonicCurrentAttribute", + readElectricalMeasurementMeasured7thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasured9thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured9thHarmonicCurrentCommandParams); + result.put( + "readMeasured9thHarmonicCurrentAttribute", + readElectricalMeasurementMeasured9thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasured11thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasured11thHarmonicCurrentCommandParams); + result.put( + "readMeasured11thHarmonicCurrentAttribute", + readElectricalMeasurementMeasured11thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasuredPhase1stHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase1stHarmonicCurrentCommandParams); + result.put( + "readMeasuredPhase1stHarmonicCurrentAttribute", + readElectricalMeasurementMeasuredPhase1stHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasuredPhase3rdHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentCommandParams); + result.put( + "readMeasuredPhase3rdHarmonicCurrentAttribute", + readElectricalMeasurementMeasuredPhase3rdHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasuredPhase5thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase5thHarmonicCurrentCommandParams); + result.put( + "readMeasuredPhase5thHarmonicCurrentAttribute", + readElectricalMeasurementMeasuredPhase5thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasuredPhase7thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase7thHarmonicCurrentCommandParams); + result.put( + "readMeasuredPhase7thHarmonicCurrentAttribute", + readElectricalMeasurementMeasuredPhase7thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasuredPhase9thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase9thHarmonicCurrentCommandParams); + result.put( + "readMeasuredPhase9thHarmonicCurrentAttribute", + readElectricalMeasurementMeasuredPhase9thHarmonicCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasuredPhase11thHarmonicCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementMeasuredPhase11thHarmonicCurrentCommandParams); + result.put( + "readMeasuredPhase11thHarmonicCurrentAttribute", + readElectricalMeasurementMeasuredPhase11thHarmonicCurrentAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcFrequencyMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyMultiplierCommandParams); + result.put( + "readAcFrequencyMultiplierAttribute", + readElectricalMeasurementAcFrequencyMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcFrequencyDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcFrequencyDivisorAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcFrequencyDivisorCommandParams); + result.put( + "readAcFrequencyDivisorAttribute", + readElectricalMeasurementAcFrequencyDivisorAttributeInteractionInfo); + Map readElectricalMeasurementPowerMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readPowerMultiplierAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementPowerMultiplierCommandParams); + result.put( + "readPowerMultiplierAttribute", + readElectricalMeasurementPowerMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementPowerDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readPowerDivisorAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementPowerDivisorCommandParams); + result.put( + "readPowerDivisorAttribute", readElectricalMeasurementPowerDivisorAttributeInteractionInfo); + Map + readElectricalMeasurementHarmonicCurrentMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readHarmonicCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementHarmonicCurrentMultiplierCommandParams); + result.put( + "readHarmonicCurrentMultiplierAttribute", + readElectricalMeasurementHarmonicCurrentMultiplierAttributeInteractionInfo); + Map + readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readPhaseHarmonicCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPhaseHarmonicCurrentMultiplierCommandParams); + result.put( + "readPhaseHarmonicCurrentMultiplierAttribute", + readElectricalMeasurementPhaseHarmonicCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readInstantaneousVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousVoltageCommandParams); + result.put( + "readInstantaneousVoltageAttribute", + readElectricalMeasurementInstantaneousVoltageAttributeInteractionInfo); + Map + readElectricalMeasurementInstantaneousLineCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readInstantaneousLineCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousLineCurrentCommandParams); + result.put( + "readInstantaneousLineCurrentAttribute", + readElectricalMeasurementInstantaneousLineCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementInstantaneousActiveCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readInstantaneousActiveCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousActiveCurrentCommandParams); + result.put( + "readInstantaneousActiveCurrentAttribute", + readElectricalMeasurementInstantaneousActiveCurrentAttributeInteractionInfo); + Map + readElectricalMeasurementInstantaneousReactiveCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readInstantaneousReactiveCurrentAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousReactiveCurrentCommandParams); + result.put( + "readInstantaneousReactiveCurrentAttribute", + readElectricalMeasurementInstantaneousReactiveCurrentAttributeInteractionInfo); + Map readElectricalMeasurementInstantaneousPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readInstantaneousPowerAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementInstantaneousPowerCommandParams); + result.put( + "readInstantaneousPowerAttribute", + readElectricalMeasurementInstantaneousPowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams); + result.put( + "readRmsVoltageAttribute", readElectricalMeasurementRmsVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMinCommandParams); + result.put( + "readRmsVoltageMinAttribute", + readElectricalMeasurementRmsVoltageMinAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMaxCommandParams); + result.put( + "readRmsVoltageMaxAttribute", + readElectricalMeasurementRmsVoltageMaxAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentCommandParams); + result.put( + "readRmsCurrentAttribute", readElectricalMeasurementRmsCurrentAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMinCommandParams); + result.put( + "readRmsCurrentMinAttribute", + readElectricalMeasurementRmsCurrentMinAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMaxCommandParams); + result.put( + "readRmsCurrentMaxAttribute", + readElectricalMeasurementRmsCurrentMaxAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerCommandParams); + result.put( + "readActivePowerAttribute", readElectricalMeasurementActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMinCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerMinAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMinCommandParams); + result.put( + "readActivePowerMinAttribute", + readElectricalMeasurementActivePowerMinAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerMaxAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMaxCommandParams); + result.put( + "readActivePowerMaxAttribute", + readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementReactivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readReactivePowerAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactivePowerCommandParams); + result.put( + "readReactivePowerAttribute", + readElectricalMeasurementReactivePowerAttributeInteractionInfo); + Map readElectricalMeasurementApparentPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementApparentPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readApparentPowerAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementApparentPowerCommandParams); + result.put( + "readApparentPowerAttribute", + readElectricalMeasurementApparentPowerAttributeInteractionInfo); + Map readElectricalMeasurementPowerFactorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerFactorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readPowerFactorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPowerFactorCommandParams); + result.put( + "readPowerFactorAttribute", readElectricalMeasurementPowerFactorAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsVoltageMeasurementPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams); + result.put( + "readAverageRmsVoltageMeasurementPeriodAttribute", + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsUnderVoltageCounterAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams); + result.put( + "readAverageRmsUnderVoltageCounterAttribute", + readElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); + Map + readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeOverVoltagePeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams); + result.put( + "readRmsExtremeOverVoltagePeriodAttribute", + readElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); + Map + readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeUnderVoltagePeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams); + result.put( + "readRmsExtremeUnderVoltagePeriodAttribute", + readElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSagPeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSagPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagPeriodCommandParams); + result.put( + "readRmsVoltageSagPeriodAttribute", + readElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSwellPeriodCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSwellPeriodAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellPeriodCommandParams); + result.put( + "readRmsVoltageSwellPeriodAttribute", + readElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); + Map readElectricalMeasurementAcVoltageMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcVoltageMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcVoltageMultiplierCommandParams); + result.put( + "readAcVoltageMultiplierAttribute", + readElectricalMeasurementAcVoltageMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcVoltageDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcVoltageDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcVoltageDivisorCommandParams); + result.put( + "readAcVoltageDivisorAttribute", + readElectricalMeasurementAcVoltageDivisorAttributeInteractionInfo); + Map readElectricalMeasurementAcCurrentMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcCurrentMultiplierAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcCurrentMultiplierCommandParams); + result.put( + "readAcCurrentMultiplierAttribute", + readElectricalMeasurementAcCurrentMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcCurrentDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcCurrentDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcCurrentDivisorCommandParams); + result.put( + "readAcCurrentDivisorAttribute", + readElectricalMeasurementAcCurrentDivisorAttributeInteractionInfo); + Map readElectricalMeasurementAcPowerMultiplierCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcPowerMultiplierAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcPowerMultiplierCommandParams); + result.put( + "readAcPowerMultiplierAttribute", + readElectricalMeasurementAcPowerMultiplierAttributeInteractionInfo); + Map readElectricalMeasurementAcPowerDivisorCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcPowerDivisorAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcPowerDivisorCommandParams); + result.put( + "readAcPowerDivisorAttribute", + readElectricalMeasurementAcPowerDivisorAttributeInteractionInfo); + Map readElectricalMeasurementOverloadAlarmsMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readOverloadAlarmsMaskAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementOverloadAlarmsMaskCommandParams); + result.put( + "readOverloadAlarmsMaskAttribute", + readElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); + Map readElectricalMeasurementVoltageOverloadCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementVoltageOverloadAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readVoltageOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementVoltageOverloadCommandParams); + result.put( + "readVoltageOverloadAttribute", + readElectricalMeasurementVoltageOverloadAttributeInteractionInfo); + Map readElectricalMeasurementCurrentOverloadCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementCurrentOverloadAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readCurrentOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementCurrentOverloadCommandParams); + result.put( + "readCurrentOverloadAttribute", + readElectricalMeasurementCurrentOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcOverloadAlarmsMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcOverloadAlarmsMaskAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcOverloadAlarmsMaskCommandParams); + result.put( + "readAcOverloadAlarmsMaskAttribute", + readElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); + Map readElectricalMeasurementAcVoltageOverloadCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcVoltageOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcVoltageOverloadCommandParams); + result.put( + "readAcVoltageOverloadAttribute", + readElectricalMeasurementAcVoltageOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcCurrentOverloadCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcCurrentOverloadAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcCurrentOverloadCommandParams); + result.put( + "readAcCurrentOverloadAttribute", + readElectricalMeasurementAcCurrentOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAcActivePowerOverloadCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcActivePowerOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcActivePowerOverloadCommandParams); + result.put( + "readAcActivePowerOverloadAttribute", + readElectricalMeasurementAcActivePowerOverloadAttributeInteractionInfo); + Map + readElectricalMeasurementAcReactivePowerOverloadCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcReactivePowerOverloadAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAcReactivePowerOverloadCommandParams); + result.put( + "readAcReactivePowerOverloadAttribute", + readElectricalMeasurementAcReactivePowerOverloadAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsOverVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsOverVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsOverVoltageCommandParams); + result.put( + "readAverageRmsOverVoltageAttribute", + readElectricalMeasurementAverageRmsOverVoltageAttributeInteractionInfo); + Map readElectricalMeasurementAverageRmsUnderVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsUnderVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCommandParams); + result.put( + "readAverageRmsUnderVoltageAttribute", + readElectricalMeasurementAverageRmsUnderVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeOverVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeOverVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltageCommandParams); + result.put( + "readRmsExtremeOverVoltageAttribute", + readElectricalMeasurementRmsExtremeOverVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsExtremeUnderVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeUnderVoltageAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltageCommandParams); + result.put( + "readRmsExtremeUnderVoltageAttribute", + readElectricalMeasurementRmsExtremeUnderVoltageAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSagCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSagAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagCommandParams); + result.put( + "readRmsVoltageSagAttribute", + readElectricalMeasurementRmsVoltageSagAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageSwellCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSwellAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellCommandParams); + result.put( + "readRmsVoltageSwellAttribute", + readElectricalMeasurementRmsVoltageSwellAttributeInteractionInfo); + Map readElectricalMeasurementLineCurrentPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readLineCurrentPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementLineCurrentPhaseBCommandParams); + result.put( + "readLineCurrentPhaseBAttribute", + readElectricalMeasurementLineCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActiveCurrentPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActiveCurrentPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActiveCurrentPhaseBCommandParams); + result.put( + "readActiveCurrentPhaseBAttribute", + readElectricalMeasurementActiveCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementReactiveCurrentPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readReactiveCurrentPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactiveCurrentPhaseBCommandParams); + result.put( + "readReactiveCurrentPhaseBAttribute", + readElectricalMeasurementReactiveCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltagePhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltagePhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltagePhaseBCommandParams); + result.put( + "readRmsVoltagePhaseBAttribute", + readElectricalMeasurementRmsVoltagePhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMinPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageMinPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMinPhaseBCommandParams); + result.put( + "readRmsVoltageMinPhaseBAttribute", + readElectricalMeasurementRmsVoltageMinPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageMaxPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMaxPhaseBCommandParams); + result.put( + "readRmsVoltageMaxPhaseBAttribute", + readElectricalMeasurementRmsVoltageMaxPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentPhaseBCommandParams); + result.put( + "readRmsCurrentPhaseBAttribute", + readElectricalMeasurementRmsCurrentPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMinPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentMinPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMinPhaseBCommandParams); + result.put( + "readRmsCurrentMinPhaseBAttribute", + readElectricalMeasurementRmsCurrentMinPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentMaxPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMaxPhaseBCommandParams); + result.put( + "readRmsCurrentMaxPhaseBAttribute", + readElectricalMeasurementRmsCurrentMaxPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerPhaseBCommandParams); + result.put( + "readActivePowerPhaseBAttribute", + readElectricalMeasurementActivePowerPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMinPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerMinPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMinPhaseBCommandParams); + result.put( + "readActivePowerMinPhaseBAttribute", + readElectricalMeasurementActivePowerMinPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMaxPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerMaxPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMaxPhaseBCommandParams); + result.put( + "readActivePowerMaxPhaseBAttribute", + readElectricalMeasurementActivePowerMaxPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementReactivePowerPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readReactivePowerPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactivePowerPhaseBCommandParams); + result.put( + "readReactivePowerPhaseBAttribute", + readElectricalMeasurementReactivePowerPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementApparentPowerPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readApparentPowerPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementApparentPowerPhaseBCommandParams); + result.put( + "readApparentPowerPhaseBAttribute", + readElectricalMeasurementApparentPowerPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementPowerFactorPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readPowerFactorPhaseBAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPowerFactorPhaseBCommandParams); + result.put( + "readPowerFactorPhaseBAttribute", + readElectricalMeasurementPowerFactorPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsVoltageMeasurementPeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBCommandParams); + result.put( + "readAverageRmsVoltageMeasurementPeriodPhaseBAttribute", + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsOverVoltageCounterPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBCommandParams); + result.put( + "readAverageRmsOverVoltageCounterPhaseBAttribute", + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsUnderVoltageCounterPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBCommandParams); + result.put( + "readAverageRmsUnderVoltageCounterPhaseBAttribute", + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeOverVoltagePeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBCommandParams); + result.put( + "readRmsExtremeOverVoltagePeriodPhaseBAttribute", + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeUnderVoltagePeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBCommandParams); + result.put( + "readRmsExtremeUnderVoltagePeriodPhaseBAttribute", + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSagPeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagPeriodPhaseBCommandParams); + result.put( + "readRmsVoltageSagPeriodPhaseBAttribute", + readElectricalMeasurementRmsVoltageSagPeriodPhaseBAttributeInteractionInfo); + Map + readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSwellPeriodPhaseBAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellPeriodPhaseBCommandParams); + result.put( + "readRmsVoltageSwellPeriodPhaseBAttribute", + readElectricalMeasurementRmsVoltageSwellPeriodPhaseBAttributeInteractionInfo); + Map readElectricalMeasurementLineCurrentPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readLineCurrentPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementLineCurrentPhaseCCommandParams); + result.put( + "readLineCurrentPhaseCAttribute", + readElectricalMeasurementLineCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActiveCurrentPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActiveCurrentPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActiveCurrentPhaseCCommandParams); + result.put( + "readActiveCurrentPhaseCAttribute", + readElectricalMeasurementActiveCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementReactiveCurrentPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readReactiveCurrentPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactiveCurrentPhaseCCommandParams); + result.put( + "readReactiveCurrentPhaseCAttribute", + readElectricalMeasurementReactiveCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltagePhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltagePhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltagePhaseCCommandParams); + result.put( + "readRmsVoltagePhaseCAttribute", + readElectricalMeasurementRmsVoltagePhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMinPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageMinPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMinPhaseCCommandParams); + result.put( + "readRmsVoltageMinPhaseCAttribute", + readElectricalMeasurementRmsVoltageMinPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageMaxPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageMaxPhaseCCommandParams); + result.put( + "readRmsVoltageMaxPhaseCAttribute", + readElectricalMeasurementRmsVoltageMaxPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentPhaseCCommandParams); + result.put( + "readRmsCurrentPhaseCAttribute", + readElectricalMeasurementRmsCurrentPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMinPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentMinPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMinPhaseCCommandParams); + result.put( + "readRmsCurrentMinPhaseCAttribute", + readElectricalMeasurementRmsCurrentMinPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsCurrentMaxPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsCurrentMaxPhaseCCommandParams); + result.put( + "readRmsCurrentMaxPhaseCAttribute", + readElectricalMeasurementRmsCurrentMaxPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerPhaseCCommandParams); + result.put( + "readActivePowerPhaseCAttribute", + readElectricalMeasurementActivePowerPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMinPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerMinPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMinPhaseCCommandParams); + result.put( + "readActivePowerMinPhaseCAttribute", + readElectricalMeasurementActivePowerMinPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementActivePowerMaxPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readActivePowerMaxPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementActivePowerMaxPhaseCCommandParams); + result.put( + "readActivePowerMaxPhaseCAttribute", + readElectricalMeasurementActivePowerMaxPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementReactivePowerPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readReactivePowerPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementReactivePowerPhaseCCommandParams); + result.put( + "readReactivePowerPhaseCAttribute", + readElectricalMeasurementReactivePowerPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementApparentPowerPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readApparentPowerPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementApparentPowerPhaseCCommandParams); + result.put( + "readApparentPowerPhaseCAttribute", + readElectricalMeasurementApparentPowerPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementPowerFactorPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readPowerFactorPhaseCAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementPowerFactorPhaseCCommandParams); + result.put( + "readPowerFactorPhaseCAttribute", + readElectricalMeasurementPowerFactorPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsVoltageMeasurementPeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCCommandParams); + result.put( + "readAverageRmsVoltageMeasurementPeriodPhaseCAttribute", + readElectricalMeasurementAverageRmsVoltageMeasurementPeriodPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsOverVoltageCounterPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCCommandParams); + result.put( + "readAverageRmsOverVoltageCounterPhaseCAttribute", + readElectricalMeasurementAverageRmsOverVoltageCounterPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAverageRmsUnderVoltageCounterPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCCommandParams); + result.put( + "readAverageRmsUnderVoltageCounterPhaseCAttribute", + readElectricalMeasurementAverageRmsUnderVoltageCounterPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeOverVoltagePeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCCommandParams); + result.put( + "readRmsExtremeOverVoltagePeriodPhaseCAttribute", + readElectricalMeasurementRmsExtremeOverVoltagePeriodPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsExtremeUnderVoltagePeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCCommandParams); + result.put( + "readRmsExtremeUnderVoltagePeriodPhaseCAttribute", + readElectricalMeasurementRmsExtremeUnderVoltagePeriodPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSagPeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSagPeriodPhaseCCommandParams); + result.put( + "readRmsVoltageSagPeriodPhaseCAttribute", + readElectricalMeasurementRmsVoltageSagPeriodPhaseCAttributeInteractionInfo); + Map + readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageSwellPeriodPhaseCAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageSwellPeriodPhaseCCommandParams); + result.put( + "readRmsVoltageSwellPeriodPhaseCAttribute", + readElectricalMeasurementRmsVoltageSwellPeriodPhaseCAttributeInteractionInfo); + Map readElectricalMeasurementGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.ElectricalMeasurementCluster + .GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterGeneratedCommandListAttributeCallback(), + readElectricalMeasurementGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readElectricalMeasurementGeneratedCommandListAttributeInteractionInfo); + Map readElectricalMeasurementAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.ElectricalMeasurementCluster + .AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterAcceptedCommandListAttributeCallback(), + readElectricalMeasurementAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readElectricalMeasurementAcceptedCommandListAttributeInteractionInfo); + Map readElectricalMeasurementEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readEventListAttribute( + (ChipClusters.ElectricalMeasurementCluster.EventListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterEventListAttributeCallback(), + readElectricalMeasurementEventListCommandParams); + result.put( + "readEventListAttribute", readElectricalMeasurementEventListAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams); + result.put( + "readAttributeListAttribute", + readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readElectricalMeasurementFeatureMapCommandParams); + result.put( + "readFeatureMapAttribute", readElectricalMeasurementFeatureMapAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", + readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readUnitTestingInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readUnitTestingBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingBooleanCommandParams); + result.put("readBooleanAttribute", readUnitTestingBooleanAttributeInteractionInfo); + Map readUnitTestingBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingBitmap8CommandParams); + result.put("readBitmap8Attribute", readUnitTestingBitmap8AttributeInteractionInfo); + Map readUnitTestingBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingBitmap16CommandParams); + result.put("readBitmap16Attribute", readUnitTestingBitmap16AttributeInteractionInfo); + Map readUnitTestingBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingBitmap32CommandParams); + result.put("readBitmap32Attribute", readUnitTestingBitmap32AttributeInteractionInfo); + Map readUnitTestingBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingBitmap64CommandParams); + result.put("readBitmap64Attribute", readUnitTestingBitmap64AttributeInteractionInfo); + Map readUnitTestingInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt8uCommandParams); + result.put("readInt8uAttribute", readUnitTestingInt8uAttributeInteractionInfo); + Map readUnitTestingInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt16uCommandParams); + result.put("readInt16uAttribute", readUnitTestingInt16uAttributeInteractionInfo); + Map readUnitTestingInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt24uCommandParams); + result.put("readInt24uAttribute", readUnitTestingInt24uAttributeInteractionInfo); + Map readUnitTestingInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt32uCommandParams); + result.put("readInt32uAttribute", readUnitTestingInt32uAttributeInteractionInfo); + Map readUnitTestingInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt40uCommandParams); + result.put("readInt40uAttribute", readUnitTestingInt40uAttributeInteractionInfo); + Map readUnitTestingInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt48uCommandParams); + result.put("readInt48uAttribute", readUnitTestingInt48uAttributeInteractionInfo); + Map readUnitTestingInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt56uCommandParams); + result.put("readInt56uAttribute", readUnitTestingInt56uAttributeInteractionInfo); + Map readUnitTestingInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt64uCommandParams); + result.put("readInt64uAttribute", readUnitTestingInt64uAttributeInteractionInfo); + Map readUnitTestingInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt8sCommandParams); + result.put("readInt8sAttribute", readUnitTestingInt8sAttributeInteractionInfo); + Map readUnitTestingInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingInt16sCommandParams); + result.put("readInt16sAttribute", readUnitTestingInt16sAttributeInteractionInfo); + Map readUnitTestingInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt24sCommandParams); + result.put("readInt24sAttribute", readUnitTestingInt24sAttributeInteractionInfo); + Map readUnitTestingInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt32sCommandParams); + result.put("readInt32sAttribute", readUnitTestingInt32sAttributeInteractionInfo); + Map readUnitTestingInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt40sCommandParams); + result.put("readInt40sAttribute", readUnitTestingInt40sAttributeInteractionInfo); + Map readUnitTestingInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt48sCommandParams); + result.put("readInt48sAttribute", readUnitTestingInt48sAttributeInteractionInfo); + Map readUnitTestingInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt56sCommandParams); + result.put("readInt56sAttribute", readUnitTestingInt56sAttributeInteractionInfo); + Map readUnitTestingInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingInt64sCommandParams); + result.put("readInt64sAttribute", readUnitTestingInt64sAttributeInteractionInfo); + Map readUnitTestingEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingEnum8CommandParams); + result.put("readEnum8Attribute", readUnitTestingEnum8AttributeInteractionInfo); + Map readUnitTestingEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingEnum16CommandParams); + result.put("readEnum16Attribute", readUnitTestingEnum16AttributeInteractionInfo); + Map readUnitTestingFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readUnitTestingFloatSingleCommandParams); + result.put("readFloatSingleAttribute", readUnitTestingFloatSingleAttributeInteractionInfo); + Map readUnitTestingFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), + readUnitTestingFloatDoubleCommandParams); + result.put("readFloatDoubleAttribute", readUnitTestingFloatDoubleAttributeInteractionInfo); + Map readUnitTestingOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), + readUnitTestingOctetStringCommandParams); + result.put("readOctetStringAttribute", readUnitTestingOctetStringAttributeInteractionInfo); + Map readUnitTestingListInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingListInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readListInt8uAttribute( + (ChipClusters.UnitTestingCluster.ListInt8uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterListInt8uAttributeCallback(), + readUnitTestingListInt8uCommandParams); + result.put("readListInt8uAttribute", readUnitTestingListInt8uAttributeInteractionInfo); + Map readUnitTestingListOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingListOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readListOctetStringAttribute( + (ChipClusters.UnitTestingCluster.ListOctetStringAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterListOctetStringAttributeCallback(), + readUnitTestingListOctetStringCommandParams); + result.put( + "readListOctetStringAttribute", readUnitTestingListOctetStringAttributeInteractionInfo); + Map readUnitTestingListStructOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingListStructOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readListStructOctetStringAttribute( + (ChipClusters.UnitTestingCluster.ListStructOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterListStructOctetStringAttributeCallback(), + readUnitTestingListStructOctetStringCommandParams); + result.put( + "readListStructOctetStringAttribute", + readUnitTestingListStructOctetStringAttributeInteractionInfo); + Map readUnitTestingLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readLongOctetStringAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), + readUnitTestingLongOctetStringCommandParams); + result.put( + "readLongOctetStringAttribute", readUnitTestingLongOctetStringAttributeInteractionInfo); + Map readUnitTestingCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readUnitTestingCharStringCommandParams); + result.put("readCharStringAttribute", readUnitTestingCharStringAttributeInteractionInfo); + Map readUnitTestingLongCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), + readUnitTestingLongCharStringCommandParams); + result.put( + "readLongCharStringAttribute", readUnitTestingLongCharStringAttributeInteractionInfo); + Map readUnitTestingEpochUsCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingEpochUsCommandParams); + result.put("readEpochUsAttribute", readUnitTestingEpochUsAttributeInteractionInfo); + Map readUnitTestingEpochSCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingEpochSCommandParams); + result.put("readEpochSAttribute", readUnitTestingEpochSAttributeInteractionInfo); + Map readUnitTestingVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingVendorIdCommandParams); + result.put("readVendorIdAttribute", readUnitTestingVendorIdAttributeInteractionInfo); + Map readUnitTestingListNullablesAndOptionalsStructCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readListNullablesAndOptionalsStructAttribute( + (ChipClusters.UnitTestingCluster + .ListNullablesAndOptionalsStructAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterListNullablesAndOptionalsStructAttributeCallback(), + readUnitTestingListNullablesAndOptionalsStructCommandParams); + result.put( + "readListNullablesAndOptionalsStructAttribute", + readUnitTestingListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readUnitTestingEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingEnumAttrCommandParams); + result.put("readEnumAttrAttribute", readUnitTestingEnumAttrAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readRangeRestrictedInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt8uCommandParams); + result.put( + "readRangeRestrictedInt8uAttribute", + readUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readRangeRestrictedInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt8sCommandParams); + result.put( + "readRangeRestrictedInt8sAttribute", + readUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readRangeRestrictedInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt16uCommandParams); + result.put( + "readRangeRestrictedInt16uAttribute", + readUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); + Map readUnitTestingRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readRangeRestrictedInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingRangeRestrictedInt16sCommandParams); + result.put( + "readRangeRestrictedInt16sAttribute", + readUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); + Map readUnitTestingListLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingListLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readListLongOctetStringAttribute( + (ChipClusters.UnitTestingCluster.ListLongOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterListLongOctetStringAttributeCallback(), + readUnitTestingListLongOctetStringCommandParams); + result.put( + "readListLongOctetStringAttribute", + readUnitTestingListLongOctetStringAttributeInteractionInfo); + Map readUnitTestingListFabricScopedCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingListFabricScopedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readListFabricScopedAttribute( + (ChipClusters.UnitTestingCluster.ListFabricScopedAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterListFabricScopedAttributeCallback(), + readUnitTestingListFabricScopedCommandParams); + result.put( + "readListFabricScopedAttribute", readUnitTestingListFabricScopedAttributeInteractionInfo); + Map readUnitTestingTimedWriteBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingTimedWriteBooleanCommandParams); + result.put( + "readTimedWriteBooleanAttribute", readUnitTestingTimedWriteBooleanAttributeInteractionInfo); + Map readUnitTestingGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readGeneralErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingGeneralErrorBooleanCommandParams); + result.put( + "readGeneralErrorBooleanAttribute", + readUnitTestingGeneralErrorBooleanAttributeInteractionInfo); + Map readUnitTestingClusterErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readClusterErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingClusterErrorBooleanCommandParams); + result.put( + "readClusterErrorBooleanAttribute", + readUnitTestingClusterErrorBooleanAttributeInteractionInfo); + Map readUnitTestingUnsupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), + readUnitTestingUnsupportedCommandParams); + result.put("readUnsupportedAttribute", readUnitTestingUnsupportedAttributeInteractionInfo); + Map readUnitTestingNullableBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableBooleanAttribute( + (ChipClusters.UnitTestingCluster.NullableBooleanAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableBooleanAttributeCallback(), + readUnitTestingNullableBooleanCommandParams); + result.put( + "readNullableBooleanAttribute", readUnitTestingNullableBooleanAttributeInteractionInfo); + Map readUnitTestingNullableBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableBitmap8Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap8AttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableBitmap8AttributeCallback(), + readUnitTestingNullableBitmap8CommandParams); + result.put( + "readNullableBitmap8Attribute", readUnitTestingNullableBitmap8AttributeInteractionInfo); + Map readUnitTestingNullableBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableBitmap16Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap16AttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableBitmap16AttributeCallback(), + readUnitTestingNullableBitmap16CommandParams); + result.put( + "readNullableBitmap16Attribute", readUnitTestingNullableBitmap16AttributeInteractionInfo); + Map readUnitTestingNullableBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableBitmap32Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap32AttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableBitmap32AttributeCallback(), + readUnitTestingNullableBitmap32CommandParams); + result.put( + "readNullableBitmap32Attribute", readUnitTestingNullableBitmap32AttributeInteractionInfo); + Map readUnitTestingNullableBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableBitmap64Attribute( + (ChipClusters.UnitTestingCluster.NullableBitmap64AttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableBitmap64AttributeCallback(), + readUnitTestingNullableBitmap64CommandParams); + result.put( + "readNullableBitmap64Attribute", readUnitTestingNullableBitmap64AttributeInteractionInfo); + Map readUnitTestingNullableInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt8uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt8uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8uAttributeCallback(), + readUnitTestingNullableInt8uCommandParams); + result.put("readNullableInt8uAttribute", readUnitTestingNullableInt8uAttributeInteractionInfo); + Map readUnitTestingNullableInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt16uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt16uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16uAttributeCallback(), + readUnitTestingNullableInt16uCommandParams); + result.put( + "readNullableInt16uAttribute", readUnitTestingNullableInt16uAttributeInteractionInfo); + Map readUnitTestingNullableInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt24uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt24uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24uAttributeCallback(), + readUnitTestingNullableInt24uCommandParams); + result.put( + "readNullableInt24uAttribute", readUnitTestingNullableInt24uAttributeInteractionInfo); + Map readUnitTestingNullableInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt32uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt32uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32uAttributeCallback(), + readUnitTestingNullableInt32uCommandParams); + result.put( + "readNullableInt32uAttribute", readUnitTestingNullableInt32uAttributeInteractionInfo); + Map readUnitTestingNullableInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt40uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt40uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40uAttributeCallback(), + readUnitTestingNullableInt40uCommandParams); + result.put( + "readNullableInt40uAttribute", readUnitTestingNullableInt40uAttributeInteractionInfo); + Map readUnitTestingNullableInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt48uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt48uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48uAttributeCallback(), + readUnitTestingNullableInt48uCommandParams); + result.put( + "readNullableInt48uAttribute", readUnitTestingNullableInt48uAttributeInteractionInfo); + Map readUnitTestingNullableInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt56uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt56uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56uAttributeCallback(), + readUnitTestingNullableInt56uCommandParams); + result.put( + "readNullableInt56uAttribute", readUnitTestingNullableInt56uAttributeInteractionInfo); + Map readUnitTestingNullableInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt64uAttribute( + (ChipClusters.UnitTestingCluster.NullableInt64uAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64uAttributeCallback(), + readUnitTestingNullableInt64uCommandParams); + result.put( + "readNullableInt64uAttribute", readUnitTestingNullableInt64uAttributeInteractionInfo); + Map readUnitTestingNullableInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt8sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt8sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt8sAttributeCallback(), + readUnitTestingNullableInt8sCommandParams); + result.put("readNullableInt8sAttribute", readUnitTestingNullableInt8sAttributeInteractionInfo); + Map readUnitTestingNullableInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt16sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt16sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt16sAttributeCallback(), + readUnitTestingNullableInt16sCommandParams); + result.put( + "readNullableInt16sAttribute", readUnitTestingNullableInt16sAttributeInteractionInfo); + Map readUnitTestingNullableInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt24sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt24sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt24sAttributeCallback(), + readUnitTestingNullableInt24sCommandParams); + result.put( + "readNullableInt24sAttribute", readUnitTestingNullableInt24sAttributeInteractionInfo); + Map readUnitTestingNullableInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt32sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt32sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt32sAttributeCallback(), + readUnitTestingNullableInt32sCommandParams); + result.put( + "readNullableInt32sAttribute", readUnitTestingNullableInt32sAttributeInteractionInfo); + Map readUnitTestingNullableInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt40sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt40sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt40sAttributeCallback(), + readUnitTestingNullableInt40sCommandParams); + result.put( + "readNullableInt40sAttribute", readUnitTestingNullableInt40sAttributeInteractionInfo); + Map readUnitTestingNullableInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt48sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt48sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt48sAttributeCallback(), + readUnitTestingNullableInt48sCommandParams); + result.put( + "readNullableInt48sAttribute", readUnitTestingNullableInt48sAttributeInteractionInfo); + Map readUnitTestingNullableInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt56sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt56sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt56sAttributeCallback(), + readUnitTestingNullableInt56sCommandParams); + result.put( + "readNullableInt56sAttribute", readUnitTestingNullableInt56sAttributeInteractionInfo); + Map readUnitTestingNullableInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableInt64sAttribute( + (ChipClusters.UnitTestingCluster.NullableInt64sAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableInt64sAttributeCallback(), + readUnitTestingNullableInt64sCommandParams); + result.put( + "readNullableInt64sAttribute", readUnitTestingNullableInt64sAttributeInteractionInfo); + Map readUnitTestingNullableEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableEnum8Attribute( + (ChipClusters.UnitTestingCluster.NullableEnum8AttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum8AttributeCallback(), + readUnitTestingNullableEnum8CommandParams); + result.put("readNullableEnum8Attribute", readUnitTestingNullableEnum8AttributeInteractionInfo); + Map readUnitTestingNullableEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableEnum16Attribute( + (ChipClusters.UnitTestingCluster.NullableEnum16AttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterNullableEnum16AttributeCallback(), + readUnitTestingNullableEnum16CommandParams); + result.put( + "readNullableEnum16Attribute", readUnitTestingNullableEnum16AttributeInteractionInfo); + Map readUnitTestingNullableFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableFloatSingleAttribute( + (ChipClusters.UnitTestingCluster.NullableFloatSingleAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableFloatSingleAttributeCallback(), + readUnitTestingNullableFloatSingleCommandParams); + result.put( + "readNullableFloatSingleAttribute", + readUnitTestingNullableFloatSingleAttributeInteractionInfo); + Map readUnitTestingNullableFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableFloatDoubleAttribute( + (ChipClusters.UnitTestingCluster.NullableFloatDoubleAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableFloatDoubleAttributeCallback(), + readUnitTestingNullableFloatDoubleCommandParams); + result.put( + "readNullableFloatDoubleAttribute", + readUnitTestingNullableFloatDoubleAttributeInteractionInfo); + Map readUnitTestingNullableOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableOctetStringAttribute( + (ChipClusters.UnitTestingCluster.NullableOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableOctetStringAttributeCallback(), + readUnitTestingNullableOctetStringCommandParams); + result.put( + "readNullableOctetStringAttribute", + readUnitTestingNullableOctetStringAttributeInteractionInfo); + Map readUnitTestingNullableCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableCharStringAttribute( + (ChipClusters.UnitTestingCluster.NullableCharStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableCharStringAttributeCallback(), + readUnitTestingNullableCharStringCommandParams); + result.put( + "readNullableCharStringAttribute", + readUnitTestingNullableCharStringAttributeInteractionInfo); + Map readUnitTestingNullableEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableEnumAttrAttribute( + (ChipClusters.UnitTestingCluster.NullableEnumAttrAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableEnumAttrAttributeCallback(), + readUnitTestingNullableEnumAttrCommandParams); + result.put( + "readNullableEnumAttrAttribute", readUnitTestingNullableEnumAttrAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableRangeRestrictedInt8uAttribute( + (ChipClusters.UnitTestingCluster + .NullableRangeRestrictedInt8uAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableRangeRestrictedInt8uAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt8uCommandParams); + result.put( + "readNullableRangeRestrictedInt8uAttribute", + readUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableRangeRestrictedInt8sAttribute( + (ChipClusters.UnitTestingCluster + .NullableRangeRestrictedInt8sAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableRangeRestrictedInt8sAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt8sCommandParams); + result.put( + "readNullableRangeRestrictedInt8sAttribute", + readUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableRangeRestrictedInt16uAttribute( + (ChipClusters.UnitTestingCluster + .NullableRangeRestrictedInt16uAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableRangeRestrictedInt16uAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt16uCommandParams); + result.put( + "readNullableRangeRestrictedInt16uAttribute", + readUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readUnitTestingNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readNullableRangeRestrictedInt16sAttribute( + (ChipClusters.UnitTestingCluster + .NullableRangeRestrictedInt16sAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterNullableRangeRestrictedInt16sAttributeCallback(), + readUnitTestingNullableRangeRestrictedInt16sCommandParams); + result.put( + "readNullableRangeRestrictedInt16sAttribute", + readUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readUnitTestingWriteOnlyInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingWriteOnlyInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readWriteOnlyInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingWriteOnlyInt8uCommandParams); + result.put( + "readWriteOnlyInt8uAttribute", readUnitTestingWriteOnlyInt8uAttributeInteractionInfo); + Map readUnitTestingGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.UnitTestingCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterGeneratedCommandListAttributeCallback(), + readUnitTestingGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readUnitTestingGeneratedCommandListAttributeInteractionInfo); + Map readUnitTestingAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.UnitTestingCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedUnitTestingClusterAcceptedCommandListAttributeCallback(), + readUnitTestingAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readUnitTestingAcceptedCommandListAttributeInteractionInfo); + Map readUnitTestingEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readEventListAttribute( + (ChipClusters.UnitTestingCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterEventListAttributeCallback(), + readUnitTestingEventListCommandParams); + result.put("readEventListAttribute", readUnitTestingEventListAttributeInteractionInfo); + Map readUnitTestingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.UnitTestingCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedUnitTestingClusterAttributeListAttributeCallback(), + readUnitTestingAttributeListCommandParams); + result.put("readAttributeListAttribute", readUnitTestingAttributeListAttributeInteractionInfo); + Map readUnitTestingFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readUnitTestingFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readUnitTestingFeatureMapAttributeInteractionInfo); + Map readUnitTestingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitTestingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitTestingClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readUnitTestingClusterRevisionAttributeInteractionInfo); + + return result; + } + + private static Map readFaultInjectionInteractionInfo() { + Map result = new LinkedHashMap<>(); + Map readFaultInjectionGeneratedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFaultInjectionGeneratedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster) + .readGeneratedCommandListAttribute( + (ChipClusters.FaultInjectionCluster.GeneratedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFaultInjectionClusterGeneratedCommandListAttributeCallback(), + readFaultInjectionGeneratedCommandListCommandParams); + result.put( + "readGeneratedCommandListAttribute", + readFaultInjectionGeneratedCommandListAttributeInteractionInfo); + Map readFaultInjectionAcceptedCommandListCommandParams = + new LinkedHashMap(); + InteractionInfo readFaultInjectionAcceptedCommandListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster) + .readAcceptedCommandListAttribute( + (ChipClusters.FaultInjectionCluster.AcceptedCommandListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFaultInjectionClusterAcceptedCommandListAttributeCallback(), + readFaultInjectionAcceptedCommandListCommandParams); + result.put( + "readAcceptedCommandListAttribute", + readFaultInjectionAcceptedCommandListAttributeInteractionInfo); + Map readFaultInjectionEventListCommandParams = + new LinkedHashMap(); + InteractionInfo readFaultInjectionEventListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster) + .readEventListAttribute( + (ChipClusters.FaultInjectionCluster.EventListAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFaultInjectionClusterEventListAttributeCallback(), + readFaultInjectionEventListCommandParams); + result.put("readEventListAttribute", readFaultInjectionEventListAttributeInteractionInfo); + Map readFaultInjectionAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFaultInjectionAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FaultInjectionCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFaultInjectionClusterAttributeListAttributeCallback(), + readFaultInjectionAttributeListCommandParams); + result.put( + "readAttributeListAttribute", readFaultInjectionAttributeListAttributeInteractionInfo); + Map readFaultInjectionFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readFaultInjectionFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readFaultInjectionFeatureMapCommandParams); + result.put("readFeatureMapAttribute", readFaultInjectionFeatureMapAttributeInteractionInfo); + Map readFaultInjectionClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFaultInjectionClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FaultInjectionCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFaultInjectionClusterRevisionCommandParams); + result.put( + "readClusterRevisionAttribute", readFaultInjectionClusterRevisionAttributeInteractionInfo); + + return result; + } + + @SuppressWarnings("serial") + public Map> getReadAttributeMap() { + + return new HashMap>() { + { + put("identify", readIdentifyInteractionInfo()); + put("groups", readGroupsInteractionInfo()); + put("scenes", readScenesInteractionInfo()); + put("onOff", readOnOffInteractionInfo()); + put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo()); + put("levelControl", readLevelControlInteractionInfo()); + put("binaryInputBasic", readBinaryInputBasicInteractionInfo()); + put("pulseWidthModulation", readPulseWidthModulationInteractionInfo()); + put("descriptor", readDescriptorInteractionInfo()); + put("binding", readBindingInteractionInfo()); + put("accessControl", readAccessControlInteractionInfo()); + put("actions", readActionsInteractionInfo()); + put("basicInformation", readBasicInformationInteractionInfo()); + put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo()); + put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo()); + put("localizationConfiguration", readLocalizationConfigurationInteractionInfo()); + put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo()); + put("unitLocalization", readUnitLocalizationInteractionInfo()); + put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo()); + put("powerSource", readPowerSourceInteractionInfo()); + put("generalCommissioning", readGeneralCommissioningInteractionInfo()); + put("networkCommissioning", readNetworkCommissioningInteractionInfo()); + put("diagnosticLogs", readDiagnosticLogsInteractionInfo()); + put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo()); + put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo()); + put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo()); + put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo()); + put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo()); + put("timeSynchronization", readTimeSynchronizationInteractionInfo()); + put("bridgedDeviceBasicInformation", readBridgedDeviceBasicInformationInteractionInfo()); + put("switch", readSwitchInteractionInfo()); + put("administratorCommissioning", readAdministratorCommissioningInteractionInfo()); + put("operationalCredentials", readOperationalCredentialsInteractionInfo()); + put("groupKeyManagement", readGroupKeyManagementInteractionInfo()); + put("fixedLabel", readFixedLabelInteractionInfo()); + put("userLabel", readUserLabelInteractionInfo()); + put("proxyConfiguration", readProxyConfigurationInteractionInfo()); + put("proxyDiscovery", readProxyDiscoveryInteractionInfo()); + put("proxyValid", readProxyValidInteractionInfo()); + put("booleanState", readBooleanStateInteractionInfo()); + put("icdManagement", readIcdManagementInteractionInfo()); + put("modeSelect", readModeSelectInteractionInfo()); + put("temperatureControl", readTemperatureControlInteractionInfo()); + put("refrigeratorAlarm", readRefrigeratorAlarmInteractionInfo()); + put("airQuality", readAirQualityInteractionInfo()); + put("smokeCoAlarm", readSmokeCoAlarmInteractionInfo()); + put("dishwasherAlarm", readDishwasherAlarmInteractionInfo()); + put("hepaFilterMonitoring", readHepaFilterMonitoringInteractionInfo()); + put( + "activatedCarbonFilterMonitoring", + readActivatedCarbonFilterMonitoringInteractionInfo()); + put("ceramicFilterMonitoring", readCeramicFilterMonitoringInteractionInfo()); + put("electrostaticFilterMonitoring", readElectrostaticFilterMonitoringInteractionInfo()); + put("uvFilterMonitoring", readUvFilterMonitoringInteractionInfo()); + put("ionizingFilterMonitoring", readIonizingFilterMonitoringInteractionInfo()); + put("zeoliteFilterMonitoring", readZeoliteFilterMonitoringInteractionInfo()); + put("ozoneFilterMonitoring", readOzoneFilterMonitoringInteractionInfo()); + put("waterTankMonitoring", readWaterTankMonitoringInteractionInfo()); + put("fuelTankMonitoring", readFuelTankMonitoringInteractionInfo()); + put("inkCartridgeMonitoring", readInkCartridgeMonitoringInteractionInfo()); + put("tonerCartridgeMonitoring", readTonerCartridgeMonitoringInteractionInfo()); + put("doorLock", readDoorLockInteractionInfo()); + put("windowCovering", readWindowCoveringInteractionInfo()); + put("barrierControl", readBarrierControlInteractionInfo()); + put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo()); + put("thermostat", readThermostatInteractionInfo()); + put("fanControl", readFanControlInteractionInfo()); + put( + "thermostatUserInterfaceConfiguration", + readThermostatUserInterfaceConfigurationInteractionInfo()); + put("colorControl", readColorControlInteractionInfo()); + put("ballastConfiguration", readBallastConfigurationInteractionInfo()); + put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo()); + put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo()); + put("pressureMeasurement", readPressureMeasurementInteractionInfo()); + put("flowMeasurement", readFlowMeasurementInteractionInfo()); + put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo()); + put("occupancySensing", readOccupancySensingInteractionInfo()); + put("wakeOnLan", readWakeOnLanInteractionInfo()); + put("channel", readChannelInteractionInfo()); + put("targetNavigator", readTargetNavigatorInteractionInfo()); + put("mediaPlayback", readMediaPlaybackInteractionInfo()); + put("mediaInput", readMediaInputInteractionInfo()); + put("lowPower", readLowPowerInteractionInfo()); + put("keypadInput", readKeypadInputInteractionInfo()); + put("contentLauncher", readContentLauncherInteractionInfo()); + put("audioOutput", readAudioOutputInteractionInfo()); + put("applicationLauncher", readApplicationLauncherInteractionInfo()); + put("applicationBasic", readApplicationBasicInteractionInfo()); + put("accountLogin", readAccountLoginInteractionInfo()); + put("electricalMeasurement", readElectricalMeasurementInteractionInfo()); + put("unitTesting", readUnitTestingInteractionInfo()); + put("faultInjection", readFaultInjectionInteractionInfo()); + } + }; + } +} diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java index deaadbcc9e0a20..a5b3f16b622fd4 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java @@ -27,414 +27,323 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); + Map writeIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo identifyidentifyTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeIdentifyIdentifyTimeCommandParams.put( - "value", - identifyidentifyTimeCommandParameterInfo - ); - InteractionInfo writeIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).writeIdentifyTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeIdentifyIdentifyTimeCommandParams - ); - writeIdentifyInteractionInfo.put("writeIdentifyTimeAttribute", writeIdentifyIdentifyTimeAttributeInteractionInfo); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeIdentifyIdentifyTimeCommandParams.put("value", identifyidentifyTimeCommandParameterInfo); + InteractionInfo writeIdentifyIdentifyTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .writeIdentifyTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeIdentifyIdentifyTimeCommandParams); + writeIdentifyInteractionInfo.put( + "writeIdentifyTimeAttribute", writeIdentifyIdentifyTimeAttributeInteractionInfo); writeAttributeMap.put("identify", writeIdentifyInteractionInfo); Map writeGroupsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("groups", writeGroupsInteractionInfo); Map writeScenesInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("scenes", writeScenesInteractionInfo); Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); + Map writeOnOffOnTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo onOffonTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeOnOffOnTimeCommandParams.put( - "value", - onOffonTimeCommandParameterInfo - ); - InteractionInfo writeOnOffOnTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).writeOnTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffOnTimeCommandParams - ); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeOnOffOnTimeCommandParams.put("value", onOffonTimeCommandParameterInfo); + InteractionInfo writeOnOffOnTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .writeOnTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffOnTimeCommandParams); writeOnOffInteractionInfo.put("writeOnTimeAttribute", writeOnOffOnTimeAttributeInteractionInfo); - Map writeOnOffOffWaitTimeCommandParams = new LinkedHashMap(); + Map writeOnOffOffWaitTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeOnOffOffWaitTimeCommandParams.put( - "value", - onOffoffWaitTimeCommandParameterInfo - ); - InteractionInfo writeOnOffOffWaitTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).writeOffWaitTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffOffWaitTimeCommandParams - ); - writeOnOffInteractionInfo.put("writeOffWaitTimeAttribute", writeOnOffOffWaitTimeAttributeInteractionInfo); - Map writeOnOffStartUpOnOffCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeOnOffOffWaitTimeCommandParams.put("value", onOffoffWaitTimeCommandParameterInfo); + InteractionInfo writeOnOffOffWaitTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .writeOffWaitTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffOffWaitTimeCommandParams); + writeOnOffInteractionInfo.put( + "writeOffWaitTimeAttribute", writeOnOffOffWaitTimeAttributeInteractionInfo); + Map writeOnOffStartUpOnOffCommandParams = + new LinkedHashMap(); CommandParameterInfo onOffstartUpOnOffCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeOnOffStartUpOnOffCommandParams.put( - "value", - onOffstartUpOnOffCommandParameterInfo - ); - InteractionInfo writeOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).writeStartUpOnOffAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffStartUpOnOffCommandParams - ); - writeOnOffInteractionInfo.put("writeStartUpOnOffAttribute", writeOnOffStartUpOnOffAttributeInteractionInfo); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeOnOffStartUpOnOffCommandParams.put("value", onOffstartUpOnOffCommandParameterInfo); + InteractionInfo writeOnOffStartUpOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .writeStartUpOnOffAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffStartUpOnOffCommandParams); + writeOnOffInteractionInfo.put( + "writeStartUpOnOffAttribute", writeOnOffStartUpOnOffAttributeInteractionInfo); writeAttributeMap.put("onOff", writeOnOffInteractionInfo); - Map writeOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffSwitchConfigurationSwitchActionsCommandParams = new LinkedHashMap(); + Map writeOnOffSwitchConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map writeOnOffSwitchConfigurationSwitchActionsCommandParams = + new LinkedHashMap(); CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeOnOffSwitchConfigurationSwitchActionsCommandParams.put( - "value", - onOffSwitchConfigurationswitchActionsCommandParameterInfo - ); - InteractionInfo writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).writeSwitchActionsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOnOffSwitchConfigurationSwitchActionsCommandParams - ); - writeOnOffSwitchConfigurationInteractionInfo.put("writeSwitchActionsAttribute", writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + "value", onOffSwitchConfigurationswitchActionsCommandParameterInfo); + InteractionInfo writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .writeSwitchActionsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOnOffSwitchConfigurationSwitchActionsCommandParams); + writeOnOffSwitchConfigurationInteractionInfo.put( + "writeSwitchActionsAttribute", + writeOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); + Map writeLevelControlOptionsCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControloptionsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeLevelControlOptionsCommandParams.put( - "value", - levelControloptionsCommandParameterInfo - ); - InteractionInfo writeLevelControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeOptionsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOptionsCommandParams - ); - writeLevelControlInteractionInfo.put("writeOptionsAttribute", writeLevelControlOptionsAttributeInteractionInfo); - Map writeLevelControlOnOffTransitionTimeCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeLevelControlOptionsCommandParams.put("value", levelControloptionsCommandParameterInfo); + InteractionInfo writeLevelControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeOptionsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOptionsCommandParams); + writeLevelControlInteractionInfo.put( + "writeOptionsAttribute", writeLevelControlOptionsAttributeInteractionInfo); + Map writeLevelControlOnOffTransitionTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControlonOffTransitionTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeLevelControlOnOffTransitionTimeCommandParams.put( - "value", - levelControlonOffTransitionTimeCommandParameterInfo - ); - InteractionInfo writeLevelControlOnOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeOnOffTransitionTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOnOffTransitionTimeCommandParams - ); - writeLevelControlInteractionInfo.put("writeOnOffTransitionTimeAttribute", writeLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map writeLevelControlOnLevelCommandParams = new LinkedHashMap(); + "value", levelControlonOffTransitionTimeCommandParameterInfo); + InteractionInfo writeLevelControlOnOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeOnOffTransitionTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOnOffTransitionTimeCommandParams); + writeLevelControlInteractionInfo.put( + "writeOnOffTransitionTimeAttribute", + writeLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map writeLevelControlOnLevelCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControlonLevelCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeLevelControlOnLevelCommandParams.put( - "value", - levelControlonLevelCommandParameterInfo - ); - InteractionInfo writeLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeOnLevelAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOnLevelCommandParams - ); - writeLevelControlInteractionInfo.put("writeOnLevelAttribute", writeLevelControlOnLevelAttributeInteractionInfo); - Map writeLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeLevelControlOnLevelCommandParams.put("value", levelControlonLevelCommandParameterInfo); + InteractionInfo writeLevelControlOnLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeOnLevelAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOnLevelCommandParams); + writeLevelControlInteractionInfo.put( + "writeOnLevelAttribute", writeLevelControlOnLevelAttributeInteractionInfo); + Map writeLevelControlOnTransitionTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControlonTransitionTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeLevelControlOnTransitionTimeCommandParams.put( - "value", - levelControlonTransitionTimeCommandParameterInfo - ); - InteractionInfo writeLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeOnTransitionTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOnTransitionTimeCommandParams - ); - writeLevelControlInteractionInfo.put("writeOnTransitionTimeAttribute", writeLevelControlOnTransitionTimeAttributeInteractionInfo); - Map writeLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); + "value", levelControlonTransitionTimeCommandParameterInfo); + InteractionInfo writeLevelControlOnTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeOnTransitionTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOnTransitionTimeCommandParams); + writeLevelControlInteractionInfo.put( + "writeOnTransitionTimeAttribute", + writeLevelControlOnTransitionTimeAttributeInteractionInfo); + Map writeLevelControlOffTransitionTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeLevelControlOffTransitionTimeCommandParams.put( - "value", - levelControloffTransitionTimeCommandParameterInfo - ); - InteractionInfo writeLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeOffTransitionTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlOffTransitionTimeCommandParams - ); - writeLevelControlInteractionInfo.put("writeOffTransitionTimeAttribute", writeLevelControlOffTransitionTimeAttributeInteractionInfo); - Map writeLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); + "value", levelControloffTransitionTimeCommandParameterInfo); + InteractionInfo writeLevelControlOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeOffTransitionTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlOffTransitionTimeCommandParams); + writeLevelControlInteractionInfo.put( + "writeOffTransitionTimeAttribute", + writeLevelControlOffTransitionTimeAttributeInteractionInfo); + Map writeLevelControlDefaultMoveRateCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeLevelControlDefaultMoveRateCommandParams.put( - "value", - levelControldefaultMoveRateCommandParameterInfo - ); - InteractionInfo writeLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeDefaultMoveRateAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlDefaultMoveRateCommandParams - ); - writeLevelControlInteractionInfo.put("writeDefaultMoveRateAttribute", writeLevelControlDefaultMoveRateAttributeInteractionInfo); - Map writeLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); + "value", levelControldefaultMoveRateCommandParameterInfo); + InteractionInfo writeLevelControlDefaultMoveRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeDefaultMoveRateAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlDefaultMoveRateCommandParams); + writeLevelControlInteractionInfo.put( + "writeDefaultMoveRateAttribute", writeLevelControlDefaultMoveRateAttributeInteractionInfo); + Map writeLevelControlStartUpCurrentLevelCommandParams = + new LinkedHashMap(); CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeLevelControlStartUpCurrentLevelCommandParams.put( - "value", - levelControlstartUpCurrentLevelCommandParameterInfo - ); - InteractionInfo writeLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).writeStartUpCurrentLevelAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLevelControlStartUpCurrentLevelCommandParams - ); - writeLevelControlInteractionInfo.put("writeStartUpCurrentLevelAttribute", writeLevelControlStartUpCurrentLevelAttributeInteractionInfo); + "value", levelControlstartUpCurrentLevelCommandParameterInfo); + InteractionInfo writeLevelControlStartUpCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .writeStartUpCurrentLevelAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLevelControlStartUpCurrentLevelCommandParams); + writeLevelControlInteractionInfo.put( + "writeStartUpCurrentLevelAttribute", + writeLevelControlStartUpCurrentLevelAttributeInteractionInfo); writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicActiveTextCommandParams = new LinkedHashMap(); + Map writeBinaryInputBasicActiveTextCommandParams = + new LinkedHashMap(); CommandParameterInfo binaryInputBasicactiveTextCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBinaryInputBasicActiveTextCommandParams.put( - "value", - binaryInputBasicactiveTextCommandParameterInfo - ); - InteractionInfo writeBinaryInputBasicActiveTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).writeActiveTextAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicActiveTextCommandParams - ); - writeBinaryInputBasicInteractionInfo.put("writeActiveTextAttribute", writeBinaryInputBasicActiveTextAttributeInteractionInfo); - Map writeBinaryInputBasicDescriptionCommandParams = new LinkedHashMap(); + "value", binaryInputBasicactiveTextCommandParameterInfo); + InteractionInfo writeBinaryInputBasicActiveTextAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .writeActiveTextAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicActiveTextCommandParams); + writeBinaryInputBasicInteractionInfo.put( + "writeActiveTextAttribute", writeBinaryInputBasicActiveTextAttributeInteractionInfo); + Map writeBinaryInputBasicDescriptionCommandParams = + new LinkedHashMap(); CommandParameterInfo binaryInputBasicdescriptionCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBinaryInputBasicDescriptionCommandParams.put( - "value", - binaryInputBasicdescriptionCommandParameterInfo - ); - InteractionInfo writeBinaryInputBasicDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).writeDescriptionAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicDescriptionCommandParams - ); - writeBinaryInputBasicInteractionInfo.put("writeDescriptionAttribute", writeBinaryInputBasicDescriptionAttributeInteractionInfo); - Map writeBinaryInputBasicInactiveTextCommandParams = new LinkedHashMap(); + "value", binaryInputBasicdescriptionCommandParameterInfo); + InteractionInfo writeBinaryInputBasicDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .writeDescriptionAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicDescriptionCommandParams); + writeBinaryInputBasicInteractionInfo.put( + "writeDescriptionAttribute", writeBinaryInputBasicDescriptionAttributeInteractionInfo); + Map writeBinaryInputBasicInactiveTextCommandParams = + new LinkedHashMap(); CommandParameterInfo binaryInputBasicinactiveTextCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBinaryInputBasicInactiveTextCommandParams.put( - "value", - binaryInputBasicinactiveTextCommandParameterInfo - ); - InteractionInfo writeBinaryInputBasicInactiveTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).writeInactiveTextAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicInactiveTextCommandParams - ); - writeBinaryInputBasicInteractionInfo.put("writeInactiveTextAttribute", writeBinaryInputBasicInactiveTextAttributeInteractionInfo); - Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); + "value", binaryInputBasicinactiveTextCommandParameterInfo); + InteractionInfo writeBinaryInputBasicInactiveTextAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .writeInactiveTextAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicInactiveTextCommandParams); + writeBinaryInputBasicInteractionInfo.put( + "writeInactiveTextAttribute", writeBinaryInputBasicInactiveTextAttributeInteractionInfo); + Map writeBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeBinaryInputBasicOutOfServiceCommandParams.put( - "value", - binaryInputBasicoutOfServiceCommandParameterInfo - ); - InteractionInfo writeBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).writeOutOfServiceAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicOutOfServiceCommandParams - ); - writeBinaryInputBasicInteractionInfo.put("writeOutOfServiceAttribute", writeBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map writeBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); + "value", binaryInputBasicoutOfServiceCommandParameterInfo); + InteractionInfo writeBinaryInputBasicOutOfServiceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .writeOutOfServiceAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicOutOfServiceCommandParams); + writeBinaryInputBasicInteractionInfo.put( + "writeOutOfServiceAttribute", writeBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map writeBinaryInputBasicPresentValueCommandParams = + new LinkedHashMap(); CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeBinaryInputBasicPresentValueCommandParams.put( - "value", - binaryInputBasicpresentValueCommandParameterInfo - ); - InteractionInfo writeBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).writePresentValueAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicPresentValueCommandParams - ); - writeBinaryInputBasicInteractionInfo.put("writePresentValueAttribute", writeBinaryInputBasicPresentValueAttributeInteractionInfo); - Map writeBinaryInputBasicReliabilityCommandParams = new LinkedHashMap(); + "value", binaryInputBasicpresentValueCommandParameterInfo); + InteractionInfo writeBinaryInputBasicPresentValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .writePresentValueAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicPresentValueCommandParams); + writeBinaryInputBasicInteractionInfo.put( + "writePresentValueAttribute", writeBinaryInputBasicPresentValueAttributeInteractionInfo); + Map writeBinaryInputBasicReliabilityCommandParams = + new LinkedHashMap(); CommandParameterInfo binaryInputBasicreliabilityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBinaryInputBasicReliabilityCommandParams.put( - "value", - binaryInputBasicreliabilityCommandParameterInfo - ); - InteractionInfo writeBinaryInputBasicReliabilityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).writeReliabilityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBinaryInputBasicReliabilityCommandParams - ); - writeBinaryInputBasicInteractionInfo.put("writeReliabilityAttribute", writeBinaryInputBasicReliabilityAttributeInteractionInfo); + "value", binaryInputBasicreliabilityCommandParameterInfo); + InteractionInfo writeBinaryInputBasicReliabilityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .writeReliabilityAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBinaryInputBasicReliabilityCommandParams); + writeBinaryInputBasicInteractionInfo.put( + "writeReliabilityAttribute", writeBinaryInputBasicReliabilityAttributeInteractionInfo); writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); Map writePulseWidthModulationInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("pulseWidthModulation", writePulseWidthModulationInteractionInfo); @@ -447,222 +356,189 @@ public Map> getWriteAttributeMap() { Map writeActionsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("actions", writeActionsInteractionInfo); Map writeBasicInformationInteractionInfo = new LinkedHashMap<>(); - Map writeBasicInformationNodeLabelCommandParams = new LinkedHashMap(); + Map writeBasicInformationNodeLabelCommandParams = + new LinkedHashMap(); CommandParameterInfo basicInformationnodeLabelCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBasicInformationNodeLabelCommandParams.put( - "value", - basicInformationnodeLabelCommandParameterInfo - ); - InteractionInfo writeBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).writeNodeLabelAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicInformationNodeLabelCommandParams - ); - writeBasicInformationInteractionInfo.put("writeNodeLabelAttribute", writeBasicInformationNodeLabelAttributeInteractionInfo); - Map writeBasicInformationLocationCommandParams = new LinkedHashMap(); + "value", basicInformationnodeLabelCommandParameterInfo); + InteractionInfo writeBasicInformationNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .writeNodeLabelAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicInformationNodeLabelCommandParams); + writeBasicInformationInteractionInfo.put( + "writeNodeLabelAttribute", writeBasicInformationNodeLabelAttributeInteractionInfo); + Map writeBasicInformationLocationCommandParams = + new LinkedHashMap(); CommandParameterInfo basicInformationlocationCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBasicInformationLocationCommandParams.put( - "value", - basicInformationlocationCommandParameterInfo - ); - InteractionInfo writeBasicInformationLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).writeLocationAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicInformationLocationCommandParams - ); - writeBasicInformationInteractionInfo.put("writeLocationAttribute", writeBasicInformationLocationAttributeInteractionInfo); - Map writeBasicInformationLocalConfigDisabledCommandParams = new LinkedHashMap(); + "value", basicInformationlocationCommandParameterInfo); + InteractionInfo writeBasicInformationLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .writeLocationAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicInformationLocationCommandParams); + writeBasicInformationInteractionInfo.put( + "writeLocationAttribute", writeBasicInformationLocationAttributeInteractionInfo); + Map writeBasicInformationLocalConfigDisabledCommandParams = + new LinkedHashMap(); CommandParameterInfo basicInformationlocalConfigDisabledCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeBasicInformationLocalConfigDisabledCommandParams.put( - "value", - basicInformationlocalConfigDisabledCommandParameterInfo - ); - InteractionInfo writeBasicInformationLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicInformationCluster) cluster).writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicInformationLocalConfigDisabledCommandParams - ); - writeBasicInformationInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicInformationLocalConfigDisabledAttributeInteractionInfo); + "value", basicInformationlocalConfigDisabledCommandParameterInfo); + InteractionInfo writeBasicInformationLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicInformationCluster) cluster) + .writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicInformationLocalConfigDisabledCommandParams); + writeBasicInformationInteractionInfo.put( + "writeLocalConfigDisabledAttribute", + writeBasicInformationLocalConfigDisabledAttributeInteractionInfo); writeAttributeMap.put("basicInformation", writeBasicInformationInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); + Map writeOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeLocalizationConfigurationActiveLocaleCommandParams.put( - "value", - localizationConfigurationactiveLocaleCommandParameterInfo - ); - InteractionInfo writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).writeActiveLocaleAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeLocalizationConfigurationActiveLocaleCommandParams - ); - writeLocalizationConfigurationInteractionInfo.put("writeActiveLocaleAttribute", writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo); - writeAttributeMap.put("localizationConfiguration", writeLocalizationConfigurationInteractionInfo); + "value", localizationConfigurationactiveLocaleCommandParameterInfo); + InteractionInfo writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .writeActiveLocaleAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeLocalizationConfigurationActiveLocaleCommandParams); + writeLocalizationConfigurationInteractionInfo.put( + "writeActiveLocaleAttribute", + writeLocalizationConfigurationActiveLocaleAttributeInteractionInfo); + writeAttributeMap.put( + "localizationConfiguration", writeLocalizationConfigurationInteractionInfo); Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); + Map writeTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeTimeFormatLocalizationHourFormatCommandParams.put( - "value", - timeFormatLocalizationhourFormatCommandParameterInfo - ); - InteractionInfo writeTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).writeHourFormatAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTimeFormatLocalizationHourFormatCommandParams - ); - writeTimeFormatLocalizationInteractionInfo.put("writeHourFormatAttribute", writeTimeFormatLocalizationHourFormatAttributeInteractionInfo); - Map writeTimeFormatLocalizationActiveCalendarTypeCommandParams = new LinkedHashMap(); + "value", timeFormatLocalizationhourFormatCommandParameterInfo); + InteractionInfo writeTimeFormatLocalizationHourFormatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .writeHourFormatAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTimeFormatLocalizationHourFormatCommandParams); + writeTimeFormatLocalizationInteractionInfo.put( + "writeHourFormatAttribute", writeTimeFormatLocalizationHourFormatAttributeInteractionInfo); + Map writeTimeFormatLocalizationActiveCalendarTypeCommandParams = + new LinkedHashMap(); CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeTimeFormatLocalizationActiveCalendarTypeCommandParams.put( - "value", - timeFormatLocalizationactiveCalendarTypeCommandParameterInfo - ); - InteractionInfo writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).writeActiveCalendarTypeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTimeFormatLocalizationActiveCalendarTypeCommandParams - ); - writeTimeFormatLocalizationInteractionInfo.put("writeActiveCalendarTypeAttribute", writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); + "value", timeFormatLocalizationactiveCalendarTypeCommandParameterInfo); + InteractionInfo writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .writeActiveCalendarTypeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTimeFormatLocalizationActiveCalendarTypeCommandParams); + writeTimeFormatLocalizationInteractionInfo.put( + "writeActiveCalendarTypeAttribute", + writeTimeFormatLocalizationActiveCalendarTypeAttributeInteractionInfo); writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); + Map writeUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitLocalizationTemperatureUnitCommandParams.put( - "value", - unitLocalizationtemperatureUnitCommandParameterInfo - ); - InteractionInfo writeUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).writeTemperatureUnitAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitLocalizationTemperatureUnitCommandParams - ); - writeUnitLocalizationInteractionInfo.put("writeTemperatureUnitAttribute", writeUnitLocalizationTemperatureUnitAttributeInteractionInfo); + "value", unitLocalizationtemperatureUnitCommandParameterInfo); + InteractionInfo writeUnitLocalizationTemperatureUnitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .writeTemperatureUnitAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitLocalizationTemperatureUnitCommandParams); + writeUnitLocalizationInteractionInfo.put( + "writeTemperatureUnitAttribute", + writeUnitLocalizationTemperatureUnitAttributeInteractionInfo); writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writePowerSourceConfigurationInteractionInfo = + new LinkedHashMap<>(); writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); + Map writeGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeGeneralCommissioningBreadcrumbCommandParams.put( - "value", - generalCommissioningbreadcrumbCommandParameterInfo - ); - InteractionInfo writeGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).writeBreadcrumbAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeGeneralCommissioningBreadcrumbCommandParams - ); - writeGeneralCommissioningInteractionInfo.put("writeBreadcrumbAttribute", writeGeneralCommissioningBreadcrumbAttributeInteractionInfo); + "value", generalCommissioningbreadcrumbCommandParameterInfo); + InteractionInfo writeGeneralCommissioningBreadcrumbAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .writeBreadcrumbAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeGeneralCommissioningBreadcrumbCommandParams); + writeGeneralCommissioningInteractionInfo.put( + "writeBreadcrumbAttribute", writeGeneralCommissioningBreadcrumbAttributeInteractionInfo); writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); Map writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = + new LinkedHashMap(); CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeNetworkCommissioningInterfaceEnabledCommandParams.put( - "value", - networkCommissioninginterfaceEnabledCommandParameterInfo - ); - InteractionInfo writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).writeInterfaceEnabledAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeNetworkCommissioningInterfaceEnabledCommandParams - ); - writeNetworkCommissioningInteractionInfo.put("writeInterfaceEnabledAttribute", writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + "value", networkCommissioninginterfaceEnabledCommandParameterInfo); + InteractionInfo writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .writeInterfaceEnabledAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeNetworkCommissioningInterfaceEnabledCommandParams); + writeNetworkCommissioningInteractionInfo.put( + "writeInterfaceEnabledAttribute", + writeNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); @@ -670,42 +546,45 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map writeThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); Map writeTimeSynchronizationInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("timeSynchronization", writeTimeSynchronizationInteractionInfo); - Map writeBridgedDeviceBasicInformationInteractionInfo = new LinkedHashMap<>(); - Map writeBridgedDeviceBasicInformationNodeLabelCommandParams = new LinkedHashMap(); + Map writeBridgedDeviceBasicInformationInteractionInfo = + new LinkedHashMap<>(); + Map writeBridgedDeviceBasicInformationNodeLabelCommandParams = + new LinkedHashMap(); CommandParameterInfo bridgedDeviceBasicInformationnodeLabelCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBridgedDeviceBasicInformationNodeLabelCommandParams.put( - "value", - bridgedDeviceBasicInformationnodeLabelCommandParameterInfo - ); - InteractionInfo writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster).writeNodeLabelAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBridgedDeviceBasicInformationNodeLabelCommandParams - ); - writeBridgedDeviceBasicInformationInteractionInfo.put("writeNodeLabelAttribute", writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); - writeAttributeMap.put("bridgedDeviceBasicInformation", writeBridgedDeviceBasicInformationInteractionInfo); + "value", bridgedDeviceBasicInformationnodeLabelCommandParameterInfo); + InteractionInfo writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) + .writeNodeLabelAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBridgedDeviceBasicInformationNodeLabelCommandParams); + writeBridgedDeviceBasicInformationInteractionInfo.put( + "writeNodeLabelAttribute", + writeBridgedDeviceBasicInformationNodeLabelAttributeInteractionInfo); + writeAttributeMap.put( + "bridgedDeviceBasicInformation", writeBridgedDeviceBasicInformationInteractionInfo); Map writeSwitchInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); @@ -725,140 +604,119 @@ public Map> getWriteAttributeMap() { Map writeIcdManagementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("icdManagement", writeIcdManagementInteractionInfo); Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectStartUpModeCommandParams = new LinkedHashMap(); + Map writeModeSelectStartUpModeCommandParams = + new LinkedHashMap(); CommandParameterInfo modeSelectstartUpModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeModeSelectStartUpModeCommandParams.put( - "value", - modeSelectstartUpModeCommandParameterInfo - ); - InteractionInfo writeModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).writeStartUpModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeModeSelectStartUpModeCommandParams - ); - writeModeSelectInteractionInfo.put("writeStartUpModeAttribute", writeModeSelectStartUpModeAttributeInteractionInfo); - Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeModeSelectStartUpModeCommandParams.put("value", modeSelectstartUpModeCommandParameterInfo); + InteractionInfo writeModeSelectStartUpModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .writeStartUpModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeModeSelectStartUpModeCommandParams); + writeModeSelectInteractionInfo.put( + "writeStartUpModeAttribute", writeModeSelectStartUpModeAttributeInteractionInfo); + Map writeModeSelectOnModeCommandParams = + new LinkedHashMap(); CommandParameterInfo modeSelectonModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeModeSelectOnModeCommandParams.put( - "value", - modeSelectonModeCommandParameterInfo - ); - InteractionInfo writeModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).writeOnModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeModeSelectOnModeCommandParams - ); - writeModeSelectInteractionInfo.put("writeOnModeAttribute", writeModeSelectOnModeAttributeInteractionInfo); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeModeSelectOnModeCommandParams.put("value", modeSelectonModeCommandParameterInfo); + InteractionInfo writeModeSelectOnModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .writeOnModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeModeSelectOnModeCommandParams); + writeModeSelectInteractionInfo.put( + "writeOnModeAttribute", writeModeSelectOnModeAttributeInteractionInfo); writeAttributeMap.put("modeSelect", writeModeSelectInteractionInfo); Map writeTemperatureControlInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("temperatureControl", writeTemperatureControlInteractionInfo); Map writeRefrigeratorAlarmInteractionInfo = new LinkedHashMap<>(); - Map writeRefrigeratorAlarmMaskCommandParams = new LinkedHashMap(); + Map writeRefrigeratorAlarmMaskCommandParams = + new LinkedHashMap(); CommandParameterInfo refrigeratorAlarmmaskCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeRefrigeratorAlarmMaskCommandParams.put( - "value", - refrigeratorAlarmmaskCommandParameterInfo - ); - InteractionInfo writeRefrigeratorAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RefrigeratorAlarmCluster) cluster).writeMaskAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeRefrigeratorAlarmMaskCommandParams - ); - writeRefrigeratorAlarmInteractionInfo.put("writeMaskAttribute", writeRefrigeratorAlarmMaskAttributeInteractionInfo); + new CommandParameterInfo("value", Long.class, Long.class); + writeRefrigeratorAlarmMaskCommandParams.put("value", refrigeratorAlarmmaskCommandParameterInfo); + InteractionInfo writeRefrigeratorAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RefrigeratorAlarmCluster) cluster) + .writeMaskAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeRefrigeratorAlarmMaskCommandParams); + writeRefrigeratorAlarmInteractionInfo.put( + "writeMaskAttribute", writeRefrigeratorAlarmMaskAttributeInteractionInfo); writeAttributeMap.put("refrigeratorAlarm", writeRefrigeratorAlarmInteractionInfo); Map writeAirQualityInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("airQuality", writeAirQualityInteractionInfo); Map writeSmokeCoAlarmInteractionInfo = new LinkedHashMap<>(); - Map writeSmokeCoAlarmSensitivityLevelCommandParams = new LinkedHashMap(); + Map writeSmokeCoAlarmSensitivityLevelCommandParams = + new LinkedHashMap(); CommandParameterInfo smokeCoAlarmsensitivityLevelCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + 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); + "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 writeDishwasherAlarmInteractionInfo = new LinkedHashMap<>(); - Map writeDishwasherAlarmMaskCommandParams = new LinkedHashMap(); + Map writeDishwasherAlarmMaskCommandParams = + new LinkedHashMap(); CommandParameterInfo dishwasherAlarmmaskCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeDishwasherAlarmMaskCommandParams.put( - "value", - dishwasherAlarmmaskCommandParameterInfo - ); - InteractionInfo writeDishwasherAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DishwasherAlarmCluster) cluster).writeMaskAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDishwasherAlarmMaskCommandParams - ); - writeDishwasherAlarmInteractionInfo.put("writeMaskAttribute", writeDishwasherAlarmMaskAttributeInteractionInfo); + new CommandParameterInfo("value", Long.class, Long.class); + writeDishwasherAlarmMaskCommandParams.put("value", dishwasherAlarmmaskCommandParameterInfo); + InteractionInfo writeDishwasherAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster) + .writeMaskAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDishwasherAlarmMaskCommandParams); + writeDishwasherAlarmInteractionInfo.put( + "writeMaskAttribute", writeDishwasherAlarmMaskAttributeInteractionInfo); writeAttributeMap.put("dishwasherAlarm", writeDishwasherAlarmInteractionInfo); Map writeHepaFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("hepaFilterMonitoring", writeHepaFilterMonitoringInteractionInfo); - Map writeActivatedCarbonFilterMonitoringInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("activatedCarbonFilterMonitoring", writeActivatedCarbonFilterMonitoringInteractionInfo); - Map writeCeramicFilterMonitoringInteractionInfo = new LinkedHashMap<>(); + Map writeActivatedCarbonFilterMonitoringInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "activatedCarbonFilterMonitoring", writeActivatedCarbonFilterMonitoringInteractionInfo); + Map writeCeramicFilterMonitoringInteractionInfo = + new LinkedHashMap<>(); writeAttributeMap.put("ceramicFilterMonitoring", writeCeramicFilterMonitoringInteractionInfo); - Map writeElectrostaticFilterMonitoringInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("electrostaticFilterMonitoring", writeElectrostaticFilterMonitoringInteractionInfo); + Map writeElectrostaticFilterMonitoringInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "electrostaticFilterMonitoring", writeElectrostaticFilterMonitoringInteractionInfo); Map writeUvFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("uvFilterMonitoring", writeUvFilterMonitoringInteractionInfo); - Map writeIonizingFilterMonitoringInteractionInfo = new LinkedHashMap<>(); + Map writeIonizingFilterMonitoringInteractionInfo = + new LinkedHashMap<>(); writeAttributeMap.put("ionizingFilterMonitoring", writeIonizingFilterMonitoringInteractionInfo); - Map writeZeoliteFilterMonitoringInteractionInfo = new LinkedHashMap<>(); + Map writeZeoliteFilterMonitoringInteractionInfo = + new LinkedHashMap<>(); writeAttributeMap.put("zeoliteFilterMonitoring", writeZeoliteFilterMonitoringInteractionInfo); Map writeOzoneFilterMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("ozoneFilterMonitoring", writeOzoneFilterMonitoringInteractionInfo); @@ -868,1961 +726,1578 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("fuelTankMonitoring", writeFuelTankMonitoringInteractionInfo); Map writeInkCartridgeMonitoringInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("inkCartridgeMonitoring", writeInkCartridgeMonitoringInteractionInfo); - Map writeTonerCartridgeMonitoringInteractionInfo = new LinkedHashMap<>(); + Map writeTonerCartridgeMonitoringInteractionInfo = + new LinkedHashMap<>(); writeAttributeMap.put("tonerCartridgeMonitoring", writeTonerCartridgeMonitoringInteractionInfo); Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockDoorOpenEventsCommandParams = new LinkedHashMap(); + Map writeDoorLockDoorOpenEventsCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockdoorOpenEventsCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeDoorLockDoorOpenEventsCommandParams.put( - "value", - doorLockdoorOpenEventsCommandParameterInfo - ); - InteractionInfo writeDoorLockDoorOpenEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeDoorOpenEventsAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockDoorOpenEventsCommandParams - ); - writeDoorLockInteractionInfo.put("writeDoorOpenEventsAttribute", writeDoorLockDoorOpenEventsAttributeInteractionInfo); - Map writeDoorLockDoorClosedEventsCommandParams = new LinkedHashMap(); + "value", doorLockdoorOpenEventsCommandParameterInfo); + InteractionInfo writeDoorLockDoorOpenEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeDoorOpenEventsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockDoorOpenEventsCommandParams); + writeDoorLockInteractionInfo.put( + "writeDoorOpenEventsAttribute", writeDoorLockDoorOpenEventsAttributeInteractionInfo); + Map writeDoorLockDoorClosedEventsCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockdoorClosedEventsCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeDoorLockDoorClosedEventsCommandParams.put( - "value", - doorLockdoorClosedEventsCommandParameterInfo - ); - InteractionInfo writeDoorLockDoorClosedEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeDoorClosedEventsAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockDoorClosedEventsCommandParams - ); - writeDoorLockInteractionInfo.put("writeDoorClosedEventsAttribute", writeDoorLockDoorClosedEventsAttributeInteractionInfo); - Map writeDoorLockOpenPeriodCommandParams = new LinkedHashMap(); + "value", doorLockdoorClosedEventsCommandParameterInfo); + InteractionInfo writeDoorLockDoorClosedEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeDoorClosedEventsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockDoorClosedEventsCommandParams); + writeDoorLockInteractionInfo.put( + "writeDoorClosedEventsAttribute", writeDoorLockDoorClosedEventsAttributeInteractionInfo); + Map writeDoorLockOpenPeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockopenPeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeDoorLockOpenPeriodCommandParams.put( - "value", - doorLockopenPeriodCommandParameterInfo - ); - InteractionInfo writeDoorLockOpenPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeOpenPeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockOpenPeriodCommandParams - ); - writeDoorLockInteractionInfo.put("writeOpenPeriodAttribute", writeDoorLockOpenPeriodAttributeInteractionInfo); - Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeDoorLockOpenPeriodCommandParams.put("value", doorLockopenPeriodCommandParameterInfo); + InteractionInfo writeDoorLockOpenPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeOpenPeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockOpenPeriodCommandParams); + writeDoorLockInteractionInfo.put( + "writeOpenPeriodAttribute", writeDoorLockOpenPeriodAttributeInteractionInfo); + Map writeDoorLockLanguageCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLocklanguageCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); - writeDoorLockLanguageCommandParams.put( - "value", - doorLocklanguageCommandParameterInfo - ); - InteractionInfo writeDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeLanguageAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockLanguageCommandParams - ); - writeDoorLockInteractionInfo.put("writeLanguageAttribute", writeDoorLockLanguageAttributeInteractionInfo); - Map writeDoorLockLEDSettingsCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", String.class, String.class); + writeDoorLockLanguageCommandParams.put("value", doorLocklanguageCommandParameterInfo); + InteractionInfo writeDoorLockLanguageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeLanguageAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockLanguageCommandParams); + writeDoorLockInteractionInfo.put( + "writeLanguageAttribute", writeDoorLockLanguageAttributeInteractionInfo); + Map writeDoorLockLEDSettingsCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockLEDSettingsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeDoorLockLEDSettingsCommandParams.put( - "value", - doorLockLEDSettingsCommandParameterInfo - ); - InteractionInfo writeDoorLockLEDSettingsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeLEDSettingsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockLEDSettingsCommandParams - ); - writeDoorLockInteractionInfo.put("writeLEDSettingsAttribute", writeDoorLockLEDSettingsAttributeInteractionInfo); - Map writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeDoorLockLEDSettingsCommandParams.put("value", doorLockLEDSettingsCommandParameterInfo); + InteractionInfo writeDoorLockLEDSettingsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeLEDSettingsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockLEDSettingsCommandParams); + writeDoorLockInteractionInfo.put( + "writeLEDSettingsAttribute", writeDoorLockLEDSettingsAttributeInteractionInfo); + Map writeDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeDoorLockAutoRelockTimeCommandParams.put( - "value", - doorLockautoRelockTimeCommandParameterInfo - ); - InteractionInfo writeDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeAutoRelockTimeAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockAutoRelockTimeCommandParams - ); - writeDoorLockInteractionInfo.put("writeAutoRelockTimeAttribute", writeDoorLockAutoRelockTimeAttributeInteractionInfo); - Map writeDoorLockSoundVolumeCommandParams = new LinkedHashMap(); + "value", doorLockautoRelockTimeCommandParameterInfo); + InteractionInfo writeDoorLockAutoRelockTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeAutoRelockTimeAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockAutoRelockTimeCommandParams); + writeDoorLockInteractionInfo.put( + "writeAutoRelockTimeAttribute", writeDoorLockAutoRelockTimeAttributeInteractionInfo); + Map writeDoorLockSoundVolumeCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeDoorLockSoundVolumeCommandParams.put( - "value", - doorLocksoundVolumeCommandParameterInfo - ); - InteractionInfo writeDoorLockSoundVolumeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeSoundVolumeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockSoundVolumeCommandParams - ); - writeDoorLockInteractionInfo.put("writeSoundVolumeAttribute", writeDoorLockSoundVolumeAttributeInteractionInfo); - Map writeDoorLockOperatingModeCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeDoorLockSoundVolumeCommandParams.put("value", doorLocksoundVolumeCommandParameterInfo); + InteractionInfo writeDoorLockSoundVolumeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeSoundVolumeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockSoundVolumeCommandParams); + writeDoorLockInteractionInfo.put( + "writeSoundVolumeAttribute", writeDoorLockSoundVolumeAttributeInteractionInfo); + Map writeDoorLockOperatingModeCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockoperatingModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeDoorLockOperatingModeCommandParams.put( - "value", - doorLockoperatingModeCommandParameterInfo - ); - InteractionInfo writeDoorLockOperatingModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeOperatingModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockOperatingModeCommandParams - ); - writeDoorLockInteractionInfo.put("writeOperatingModeAttribute", writeDoorLockOperatingModeAttributeInteractionInfo); - Map writeDoorLockEnableLocalProgrammingCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeDoorLockOperatingModeCommandParams.put("value", doorLockoperatingModeCommandParameterInfo); + InteractionInfo writeDoorLockOperatingModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeOperatingModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockOperatingModeCommandParams); + writeDoorLockInteractionInfo.put( + "writeOperatingModeAttribute", writeDoorLockOperatingModeAttributeInteractionInfo); + Map writeDoorLockEnableLocalProgrammingCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockenableLocalProgrammingCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeDoorLockEnableLocalProgrammingCommandParams.put( - "value", - doorLockenableLocalProgrammingCommandParameterInfo - ); - InteractionInfo writeDoorLockEnableLocalProgrammingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeEnableLocalProgrammingAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnableLocalProgrammingCommandParams - ); - writeDoorLockInteractionInfo.put("writeEnableLocalProgrammingAttribute", writeDoorLockEnableLocalProgrammingAttributeInteractionInfo); - Map writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); + "value", doorLockenableLocalProgrammingCommandParameterInfo); + InteractionInfo writeDoorLockEnableLocalProgrammingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeEnableLocalProgrammingAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnableLocalProgrammingCommandParams); + writeDoorLockInteractionInfo.put( + "writeEnableLocalProgrammingAttribute", + writeDoorLockEnableLocalProgrammingAttributeInteractionInfo); + Map writeDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeDoorLockEnableOneTouchLockingCommandParams.put( - "value", - doorLockenableOneTouchLockingCommandParameterInfo - ); - InteractionInfo writeDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeEnableOneTouchLockingAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnableOneTouchLockingCommandParams - ); - writeDoorLockInteractionInfo.put("writeEnableOneTouchLockingAttribute", writeDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map writeDoorLockEnableInsideStatusLEDCommandParams = new LinkedHashMap(); + "value", doorLockenableOneTouchLockingCommandParameterInfo); + InteractionInfo writeDoorLockEnableOneTouchLockingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeEnableOneTouchLockingAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnableOneTouchLockingCommandParams); + writeDoorLockInteractionInfo.put( + "writeEnableOneTouchLockingAttribute", + writeDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map writeDoorLockEnableInsideStatusLEDCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockenableInsideStatusLEDCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeDoorLockEnableInsideStatusLEDCommandParams.put( - "value", - doorLockenableInsideStatusLEDCommandParameterInfo - ); - InteractionInfo writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeEnableInsideStatusLEDAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnableInsideStatusLEDCommandParams - ); - writeDoorLockInteractionInfo.put("writeEnableInsideStatusLEDAttribute", writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo); - Map writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); + "value", doorLockenableInsideStatusLEDCommandParameterInfo); + InteractionInfo writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeEnableInsideStatusLEDAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnableInsideStatusLEDCommandParams); + writeDoorLockInteractionInfo.put( + "writeEnableInsideStatusLEDAttribute", + writeDoorLockEnableInsideStatusLEDAttributeInteractionInfo); + Map writeDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeDoorLockEnablePrivacyModeButtonCommandParams.put( - "value", - doorLockenablePrivacyModeButtonCommandParameterInfo - ); - InteractionInfo writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeEnablePrivacyModeButtonAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockEnablePrivacyModeButtonCommandParams - ); - writeDoorLockInteractionInfo.put("writeEnablePrivacyModeButtonAttribute", writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map writeDoorLockLocalProgrammingFeaturesCommandParams = new LinkedHashMap(); + "value", doorLockenablePrivacyModeButtonCommandParameterInfo); + InteractionInfo writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeEnablePrivacyModeButtonAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockEnablePrivacyModeButtonCommandParams); + writeDoorLockInteractionInfo.put( + "writeEnablePrivacyModeButtonAttribute", + writeDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map writeDoorLockLocalProgrammingFeaturesCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLocklocalProgrammingFeaturesCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeDoorLockLocalProgrammingFeaturesCommandParams.put( - "value", - doorLocklocalProgrammingFeaturesCommandParameterInfo - ); - InteractionInfo writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeLocalProgrammingFeaturesAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockLocalProgrammingFeaturesCommandParams - ); - writeDoorLockInteractionInfo.put("writeLocalProgrammingFeaturesAttribute", writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); - Map writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); + "value", doorLocklocalProgrammingFeaturesCommandParameterInfo); + InteractionInfo writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeLocalProgrammingFeaturesAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockLocalProgrammingFeaturesCommandParams); + writeDoorLockInteractionInfo.put( + "writeLocalProgrammingFeaturesAttribute", + writeDoorLockLocalProgrammingFeaturesAttributeInteractionInfo); + Map writeDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeDoorLockWrongCodeEntryLimitCommandParams.put( - "value", - doorLockwrongCodeEntryLimitCommandParameterInfo - ); - InteractionInfo writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeWrongCodeEntryLimitAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockWrongCodeEntryLimitCommandParams - ); - writeDoorLockInteractionInfo.put("writeWrongCodeEntryLimitAttribute", writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map writeDoorLockUserCodeTemporaryDisableTimeCommandParams = new LinkedHashMap(); + "value", doorLockwrongCodeEntryLimitCommandParameterInfo); + InteractionInfo writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeWrongCodeEntryLimitAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockWrongCodeEntryLimitCommandParams); + writeDoorLockInteractionInfo.put( + "writeWrongCodeEntryLimitAttribute", + writeDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map writeDoorLockUserCodeTemporaryDisableTimeCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockuserCodeTemporaryDisableTimeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeDoorLockUserCodeTemporaryDisableTimeCommandParams.put( - "value", - doorLockuserCodeTemporaryDisableTimeCommandParameterInfo - ); - InteractionInfo writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeUserCodeTemporaryDisableTimeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockUserCodeTemporaryDisableTimeCommandParams - ); - writeDoorLockInteractionInfo.put("writeUserCodeTemporaryDisableTimeAttribute", writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); - Map writeDoorLockSendPINOverTheAirCommandParams = new LinkedHashMap(); + "value", doorLockuserCodeTemporaryDisableTimeCommandParameterInfo); + InteractionInfo writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeUserCodeTemporaryDisableTimeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockUserCodeTemporaryDisableTimeCommandParams); + writeDoorLockInteractionInfo.put( + "writeUserCodeTemporaryDisableTimeAttribute", + writeDoorLockUserCodeTemporaryDisableTimeAttributeInteractionInfo); + Map writeDoorLockSendPINOverTheAirCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLocksendPINOverTheAirCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeDoorLockSendPINOverTheAirCommandParams.put( - "value", - doorLocksendPINOverTheAirCommandParameterInfo - ); - InteractionInfo writeDoorLockSendPINOverTheAirAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeSendPINOverTheAirAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockSendPINOverTheAirCommandParams - ); - writeDoorLockInteractionInfo.put("writeSendPINOverTheAirAttribute", writeDoorLockSendPINOverTheAirAttributeInteractionInfo); - Map writeDoorLockRequirePINforRemoteOperationCommandParams = new LinkedHashMap(); + "value", doorLocksendPINOverTheAirCommandParameterInfo); + InteractionInfo writeDoorLockSendPINOverTheAirAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeSendPINOverTheAirAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockSendPINOverTheAirCommandParams); + writeDoorLockInteractionInfo.put( + "writeSendPINOverTheAirAttribute", writeDoorLockSendPINOverTheAirAttributeInteractionInfo); + Map writeDoorLockRequirePINforRemoteOperationCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockrequirePINforRemoteOperationCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeDoorLockRequirePINforRemoteOperationCommandParams.put( - "value", - doorLockrequirePINforRemoteOperationCommandParameterInfo - ); - InteractionInfo writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeRequirePINforRemoteOperationAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockRequirePINforRemoteOperationCommandParams - ); - writeDoorLockInteractionInfo.put("writeRequirePINforRemoteOperationAttribute", writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); - Map writeDoorLockExpiringUserTimeoutCommandParams = new LinkedHashMap(); + "value", doorLockrequirePINforRemoteOperationCommandParameterInfo); + InteractionInfo writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeRequirePINforRemoteOperationAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockRequirePINforRemoteOperationCommandParams); + writeDoorLockInteractionInfo.put( + "writeRequirePINforRemoteOperationAttribute", + writeDoorLockRequirePINforRemoteOperationAttributeInteractionInfo); + Map writeDoorLockExpiringUserTimeoutCommandParams = + new LinkedHashMap(); CommandParameterInfo doorLockexpiringUserTimeoutCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeDoorLockExpiringUserTimeoutCommandParams.put( - "value", - doorLockexpiringUserTimeoutCommandParameterInfo - ); - InteractionInfo writeDoorLockExpiringUserTimeoutAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).writeExpiringUserTimeoutAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeDoorLockExpiringUserTimeoutCommandParams - ); - writeDoorLockInteractionInfo.put("writeExpiringUserTimeoutAttribute", writeDoorLockExpiringUserTimeoutAttributeInteractionInfo); + "value", doorLockexpiringUserTimeoutCommandParameterInfo); + InteractionInfo writeDoorLockExpiringUserTimeoutAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .writeExpiringUserTimeoutAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeDoorLockExpiringUserTimeoutCommandParams); + writeDoorLockInteractionInfo.put( + "writeExpiringUserTimeoutAttribute", + writeDoorLockExpiringUserTimeoutAttributeInteractionInfo); writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); + Map writeWindowCoveringModeCommandParams = + new LinkedHashMap(); CommandParameterInfo windowCoveringmodeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeWindowCoveringModeCommandParams.put( - "value", - windowCoveringmodeCommandParameterInfo - ); - InteractionInfo writeWindowCoveringModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).writeModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeWindowCoveringModeCommandParams - ); - writeWindowCoveringInteractionInfo.put("writeModeAttribute", writeWindowCoveringModeAttributeInteractionInfo); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeWindowCoveringModeCommandParams.put("value", windowCoveringmodeCommandParameterInfo); + InteractionInfo writeWindowCoveringModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .writeModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeWindowCoveringModeCommandParams); + writeWindowCoveringInteractionInfo.put( + "writeModeAttribute", writeWindowCoveringModeAttributeInteractionInfo); writeAttributeMap.put("windowCovering", writeWindowCoveringInteractionInfo); Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map writeBarrierControlBarrierOpenEventsCommandParams = new LinkedHashMap(); + Map writeBarrierControlBarrierOpenEventsCommandParams = + new LinkedHashMap(); CommandParameterInfo barrierControlbarrierOpenEventsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBarrierControlBarrierOpenEventsCommandParams.put( - "value", - barrierControlbarrierOpenEventsCommandParameterInfo - ); - InteractionInfo writeBarrierControlBarrierOpenEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).writeBarrierOpenEventsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierOpenEventsCommandParams - ); - writeBarrierControlInteractionInfo.put("writeBarrierOpenEventsAttribute", writeBarrierControlBarrierOpenEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierCloseEventsCommandParams = new LinkedHashMap(); + "value", barrierControlbarrierOpenEventsCommandParameterInfo); + InteractionInfo writeBarrierControlBarrierOpenEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .writeBarrierOpenEventsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierOpenEventsCommandParams); + writeBarrierControlInteractionInfo.put( + "writeBarrierOpenEventsAttribute", + writeBarrierControlBarrierOpenEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierCloseEventsCommandParams = + new LinkedHashMap(); CommandParameterInfo barrierControlbarrierCloseEventsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBarrierControlBarrierCloseEventsCommandParams.put( - "value", - barrierControlbarrierCloseEventsCommandParameterInfo - ); - InteractionInfo writeBarrierControlBarrierCloseEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).writeBarrierCloseEventsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierCloseEventsCommandParams - ); - writeBarrierControlInteractionInfo.put("writeBarrierCloseEventsAttribute", writeBarrierControlBarrierCloseEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierCommandOpenEventsCommandParams = new LinkedHashMap(); + "value", barrierControlbarrierCloseEventsCommandParameterInfo); + InteractionInfo writeBarrierControlBarrierCloseEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .writeBarrierCloseEventsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierCloseEventsCommandParams); + writeBarrierControlInteractionInfo.put( + "writeBarrierCloseEventsAttribute", + writeBarrierControlBarrierCloseEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierCommandOpenEventsCommandParams = + new LinkedHashMap(); CommandParameterInfo barrierControlbarrierCommandOpenEventsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBarrierControlBarrierCommandOpenEventsCommandParams.put( - "value", - barrierControlbarrierCommandOpenEventsCommandParameterInfo - ); - InteractionInfo writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).writeBarrierCommandOpenEventsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierCommandOpenEventsCommandParams - ); - writeBarrierControlInteractionInfo.put("writeBarrierCommandOpenEventsAttribute", writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierCommandCloseEventsCommandParams = new LinkedHashMap(); + "value", barrierControlbarrierCommandOpenEventsCommandParameterInfo); + InteractionInfo writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .writeBarrierCommandOpenEventsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierCommandOpenEventsCommandParams); + writeBarrierControlInteractionInfo.put( + "writeBarrierCommandOpenEventsAttribute", + writeBarrierControlBarrierCommandOpenEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierCommandCloseEventsCommandParams = + new LinkedHashMap(); CommandParameterInfo barrierControlbarrierCommandCloseEventsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBarrierControlBarrierCommandCloseEventsCommandParams.put( - "value", - barrierControlbarrierCommandCloseEventsCommandParameterInfo - ); - InteractionInfo writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).writeBarrierCommandCloseEventsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierCommandCloseEventsCommandParams - ); - writeBarrierControlInteractionInfo.put("writeBarrierCommandCloseEventsAttribute", writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); - Map writeBarrierControlBarrierOpenPeriodCommandParams = new LinkedHashMap(); + "value", barrierControlbarrierCommandCloseEventsCommandParameterInfo); + InteractionInfo writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .writeBarrierCommandCloseEventsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierCommandCloseEventsCommandParams); + writeBarrierControlInteractionInfo.put( + "writeBarrierCommandCloseEventsAttribute", + writeBarrierControlBarrierCommandCloseEventsAttributeInteractionInfo); + Map writeBarrierControlBarrierOpenPeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo barrierControlbarrierOpenPeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBarrierControlBarrierOpenPeriodCommandParams.put( - "value", - barrierControlbarrierOpenPeriodCommandParameterInfo - ); - InteractionInfo writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).writeBarrierOpenPeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierOpenPeriodCommandParams - ); - writeBarrierControlInteractionInfo.put("writeBarrierOpenPeriodAttribute", writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo); - Map writeBarrierControlBarrierClosePeriodCommandParams = new LinkedHashMap(); + "value", barrierControlbarrierOpenPeriodCommandParameterInfo); + InteractionInfo writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .writeBarrierOpenPeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierOpenPeriodCommandParams); + writeBarrierControlInteractionInfo.put( + "writeBarrierOpenPeriodAttribute", + writeBarrierControlBarrierOpenPeriodAttributeInteractionInfo); + Map writeBarrierControlBarrierClosePeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo barrierControlbarrierClosePeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBarrierControlBarrierClosePeriodCommandParams.put( - "value", - barrierControlbarrierClosePeriodCommandParameterInfo - ); - InteractionInfo writeBarrierControlBarrierClosePeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).writeBarrierClosePeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBarrierControlBarrierClosePeriodCommandParams - ); - writeBarrierControlInteractionInfo.put("writeBarrierClosePeriodAttribute", writeBarrierControlBarrierClosePeriodAttributeInteractionInfo); + "value", barrierControlbarrierClosePeriodCommandParameterInfo); + InteractionInfo writeBarrierControlBarrierClosePeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .writeBarrierClosePeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBarrierControlBarrierClosePeriodCommandParams); + writeBarrierControlInteractionInfo.put( + "writeBarrierClosePeriodAttribute", + writeBarrierControlBarrierClosePeriodAttributeInteractionInfo); writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); + Map writePumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map + writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writePumpConfigurationAndControlLifetimeRunningHoursCommandParams.put( - "value", - pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo - ); - InteractionInfo writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeLifetimeRunningHoursAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlLifetimeRunningHoursCommandParams - ); - writePumpConfigurationAndControlInteractionInfo.put("writeLifetimeRunningHoursAttribute", writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); + "value", pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo); + InteractionInfo writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .writeLifetimeRunningHoursAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlLifetimeRunningHoursCommandParams); + writePumpConfigurationAndControlInteractionInfo.put( + "writeLifetimeRunningHoursAttribute", + writePumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map + writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = + new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams.put( - "value", - pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo - ); - InteractionInfo writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeLifetimeEnergyConsumedAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams - ); - writePumpConfigurationAndControlInteractionInfo.put("writeLifetimeEnergyConsumedAttribute", writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); - Map writePumpConfigurationAndControlOperationModeCommandParams = new LinkedHashMap(); + "value", pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo); + InteractionInfo writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .writeLifetimeEnergyConsumedAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); + writePumpConfigurationAndControlInteractionInfo.put( + "writeLifetimeEnergyConsumedAttribute", + writePumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo); + Map writePumpConfigurationAndControlOperationModeCommandParams = + new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writePumpConfigurationAndControlOperationModeCommandParams.put( - "value", - pumpConfigurationAndControloperationModeCommandParameterInfo - ); - InteractionInfo writePumpConfigurationAndControlOperationModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeOperationModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlOperationModeCommandParams - ); - writePumpConfigurationAndControlInteractionInfo.put("writeOperationModeAttribute", writePumpConfigurationAndControlOperationModeAttributeInteractionInfo); - Map writePumpConfigurationAndControlControlModeCommandParams = new LinkedHashMap(); + "value", pumpConfigurationAndControloperationModeCommandParameterInfo); + InteractionInfo writePumpConfigurationAndControlOperationModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .writeOperationModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlOperationModeCommandParams); + writePumpConfigurationAndControlInteractionInfo.put( + "writeOperationModeAttribute", + writePumpConfigurationAndControlOperationModeAttributeInteractionInfo); + Map writePumpConfigurationAndControlControlModeCommandParams = + new LinkedHashMap(); CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writePumpConfigurationAndControlControlModeCommandParams.put( - "value", - pumpConfigurationAndControlcontrolModeCommandParameterInfo - ); - InteractionInfo writePumpConfigurationAndControlControlModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).writeControlModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writePumpConfigurationAndControlControlModeCommandParams - ); - writePumpConfigurationAndControlInteractionInfo.put("writeControlModeAttribute", writePumpConfigurationAndControlControlModeAttributeInteractionInfo); - writeAttributeMap.put("pumpConfigurationAndControl", writePumpConfigurationAndControlInteractionInfo); + "value", pumpConfigurationAndControlcontrolModeCommandParameterInfo); + InteractionInfo writePumpConfigurationAndControlControlModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .writeControlModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writePumpConfigurationAndControlControlModeCommandParams); + writePumpConfigurationAndControlInteractionInfo.put( + "writeControlModeAttribute", + writePumpConfigurationAndControlControlModeAttributeInteractionInfo); + writeAttributeMap.put( + "pumpConfigurationAndControl", writePumpConfigurationAndControlInteractionInfo); Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatHVACSystemTypeConfigurationCommandParams = new LinkedHashMap(); + Map writeThermostatHVACSystemTypeConfigurationCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatHVACSystemTypeConfigurationCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatHVACSystemTypeConfigurationCommandParams.put( - "value", - thermostatHVACSystemTypeConfigurationCommandParameterInfo - ); - InteractionInfo writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeHVACSystemTypeConfigurationAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatHVACSystemTypeConfigurationCommandParams - ); - writeThermostatInteractionInfo.put("writeHVACSystemTypeConfigurationAttribute", writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); - Map writeThermostatLocalTemperatureCalibrationCommandParams = new LinkedHashMap(); + "value", thermostatHVACSystemTypeConfigurationCommandParameterInfo); + InteractionInfo writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeHVACSystemTypeConfigurationAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatHVACSystemTypeConfigurationCommandParams); + writeThermostatInteractionInfo.put( + "writeHVACSystemTypeConfigurationAttribute", + writeThermostatHVACSystemTypeConfigurationAttributeInteractionInfo); + Map writeThermostatLocalTemperatureCalibrationCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatlocalTemperatureCalibrationCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatLocalTemperatureCalibrationCommandParams.put( - "value", - thermostatlocalTemperatureCalibrationCommandParameterInfo - ); - InteractionInfo writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeLocalTemperatureCalibrationAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatLocalTemperatureCalibrationCommandParams - ); - writeThermostatInteractionInfo.put("writeLocalTemperatureCalibrationAttribute", writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo); - Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + "value", thermostatlocalTemperatureCalibrationCommandParameterInfo); + InteractionInfo writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeLocalTemperatureCalibrationAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatLocalTemperatureCalibrationCommandParams); + writeThermostatInteractionInfo.put( + "writeLocalTemperatureCalibrationAttribute", + writeThermostatLocalTemperatureCalibrationAttributeInteractionInfo); + Map writeThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatOccupiedCoolingSetpointCommandParams.put( - "value", - thermostatoccupiedCoolingSetpointCommandParameterInfo - ); - InteractionInfo writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeOccupiedCoolingSetpointAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatOccupiedCoolingSetpointCommandParams - ); - writeThermostatInteractionInfo.put("writeOccupiedCoolingSetpointAttribute", writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo); - Map writeThermostatOccupiedHeatingSetpointCommandParams = new LinkedHashMap(); + "value", thermostatoccupiedCoolingSetpointCommandParameterInfo); + InteractionInfo writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeOccupiedCoolingSetpointAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatOccupiedCoolingSetpointCommandParams); + writeThermostatInteractionInfo.put( + "writeOccupiedCoolingSetpointAttribute", + writeThermostatOccupiedCoolingSetpointAttributeInteractionInfo); + Map writeThermostatOccupiedHeatingSetpointCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatOccupiedHeatingSetpointCommandParams.put( - "value", - thermostatoccupiedHeatingSetpointCommandParameterInfo - ); - InteractionInfo writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeOccupiedHeatingSetpointAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatOccupiedHeatingSetpointCommandParams - ); - writeThermostatInteractionInfo.put("writeOccupiedHeatingSetpointAttribute", writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map writeThermostatUnoccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + "value", thermostatoccupiedHeatingSetpointCommandParameterInfo); + InteractionInfo writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeOccupiedHeatingSetpointAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatOccupiedHeatingSetpointCommandParams); + writeThermostatInteractionInfo.put( + "writeOccupiedHeatingSetpointAttribute", + writeThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map writeThermostatUnoccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatunoccupiedCoolingSetpointCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatUnoccupiedCoolingSetpointCommandParams.put( - "value", - thermostatunoccupiedCoolingSetpointCommandParameterInfo - ); - InteractionInfo writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeUnoccupiedCoolingSetpointAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUnoccupiedCoolingSetpointCommandParams - ); - writeThermostatInteractionInfo.put("writeUnoccupiedCoolingSetpointAttribute", writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); - Map writeThermostatUnoccupiedHeatingSetpointCommandParams = new LinkedHashMap(); + "value", thermostatunoccupiedCoolingSetpointCommandParameterInfo); + InteractionInfo writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeUnoccupiedCoolingSetpointAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUnoccupiedCoolingSetpointCommandParams); + writeThermostatInteractionInfo.put( + "writeUnoccupiedCoolingSetpointAttribute", + writeThermostatUnoccupiedCoolingSetpointAttributeInteractionInfo); + Map writeThermostatUnoccupiedHeatingSetpointCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatunoccupiedHeatingSetpointCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatUnoccupiedHeatingSetpointCommandParams.put( - "value", - thermostatunoccupiedHeatingSetpointCommandParameterInfo - ); - InteractionInfo writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeUnoccupiedHeatingSetpointAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUnoccupiedHeatingSetpointCommandParams - ); - writeThermostatInteractionInfo.put("writeUnoccupiedHeatingSetpointAttribute", writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); - Map writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + "value", thermostatunoccupiedHeatingSetpointCommandParameterInfo); + InteractionInfo writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeUnoccupiedHeatingSetpointAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUnoccupiedHeatingSetpointCommandParams); + writeThermostatInteractionInfo.put( + "writeUnoccupiedHeatingSetpointAttribute", + writeThermostatUnoccupiedHeatingSetpointAttributeInteractionInfo); + Map writeThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatMinHeatSetpointLimitCommandParams.put( - "value", - thermostatminHeatSetpointLimitCommandParameterInfo - ); - InteractionInfo writeThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeMinHeatSetpointLimitAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMinHeatSetpointLimitCommandParams - ); - writeThermostatInteractionInfo.put("writeMinHeatSetpointLimitAttribute", writeThermostatMinHeatSetpointLimitAttributeInteractionInfo); - Map writeThermostatMaxHeatSetpointLimitCommandParams = new LinkedHashMap(); + "value", thermostatminHeatSetpointLimitCommandParameterInfo); + InteractionInfo writeThermostatMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeMinHeatSetpointLimitAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMinHeatSetpointLimitCommandParams); + writeThermostatInteractionInfo.put( + "writeMinHeatSetpointLimitAttribute", + writeThermostatMinHeatSetpointLimitAttributeInteractionInfo); + Map writeThermostatMaxHeatSetpointLimitCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatMaxHeatSetpointLimitCommandParams.put( - "value", - thermostatmaxHeatSetpointLimitCommandParameterInfo - ); - InteractionInfo writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeMaxHeatSetpointLimitAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMaxHeatSetpointLimitCommandParams - ); - writeThermostatInteractionInfo.put("writeMaxHeatSetpointLimitAttribute", writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo); - Map writeThermostatMinCoolSetpointLimitCommandParams = new LinkedHashMap(); + "value", thermostatmaxHeatSetpointLimitCommandParameterInfo); + InteractionInfo writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeMaxHeatSetpointLimitAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMaxHeatSetpointLimitCommandParams); + writeThermostatInteractionInfo.put( + "writeMaxHeatSetpointLimitAttribute", + writeThermostatMaxHeatSetpointLimitAttributeInteractionInfo); + Map writeThermostatMinCoolSetpointLimitCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatMinCoolSetpointLimitCommandParams.put( - "value", - thermostatminCoolSetpointLimitCommandParameterInfo - ); - InteractionInfo writeThermostatMinCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeMinCoolSetpointLimitAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMinCoolSetpointLimitCommandParams - ); - writeThermostatInteractionInfo.put("writeMinCoolSetpointLimitAttribute", writeThermostatMinCoolSetpointLimitAttributeInteractionInfo); - Map writeThermostatMaxCoolSetpointLimitCommandParams = new LinkedHashMap(); + "value", thermostatminCoolSetpointLimitCommandParameterInfo); + InteractionInfo writeThermostatMinCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeMinCoolSetpointLimitAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMinCoolSetpointLimitCommandParams); + writeThermostatInteractionInfo.put( + "writeMinCoolSetpointLimitAttribute", + writeThermostatMinCoolSetpointLimitAttributeInteractionInfo); + Map writeThermostatMaxCoolSetpointLimitCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatMaxCoolSetpointLimitCommandParams.put( - "value", - thermostatmaxCoolSetpointLimitCommandParameterInfo - ); - InteractionInfo writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeMaxCoolSetpointLimitAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMaxCoolSetpointLimitCommandParams - ); - writeThermostatInteractionInfo.put("writeMaxCoolSetpointLimitAttribute", writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo); - Map writeThermostatMinSetpointDeadBandCommandParams = new LinkedHashMap(); + "value", thermostatmaxCoolSetpointLimitCommandParameterInfo); + InteractionInfo writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeMaxCoolSetpointLimitAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMaxCoolSetpointLimitCommandParams); + writeThermostatInteractionInfo.put( + "writeMaxCoolSetpointLimitAttribute", + writeThermostatMaxCoolSetpointLimitAttributeInteractionInfo); + Map writeThermostatMinSetpointDeadBandCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatMinSetpointDeadBandCommandParams.put( - "value", - thermostatminSetpointDeadBandCommandParameterInfo - ); - InteractionInfo writeThermostatMinSetpointDeadBandAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeMinSetpointDeadBandAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatMinSetpointDeadBandCommandParams - ); - writeThermostatInteractionInfo.put("writeMinSetpointDeadBandAttribute", writeThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map writeThermostatRemoteSensingCommandParams = new LinkedHashMap(); + "value", thermostatminSetpointDeadBandCommandParameterInfo); + InteractionInfo writeThermostatMinSetpointDeadBandAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeMinSetpointDeadBandAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatMinSetpointDeadBandCommandParams); + writeThermostatInteractionInfo.put( + "writeMinSetpointDeadBandAttribute", + writeThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map writeThermostatRemoteSensingCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatremoteSensingCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatRemoteSensingCommandParams.put( - "value", - thermostatremoteSensingCommandParameterInfo - ); - InteractionInfo writeThermostatRemoteSensingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeRemoteSensingAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatRemoteSensingCommandParams - ); - writeThermostatInteractionInfo.put("writeRemoteSensingAttribute", writeThermostatRemoteSensingAttributeInteractionInfo); - Map writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); + "value", thermostatremoteSensingCommandParameterInfo); + InteractionInfo writeThermostatRemoteSensingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeRemoteSensingAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatRemoteSensingCommandParams); + writeThermostatInteractionInfo.put( + "writeRemoteSensingAttribute", writeThermostatRemoteSensingAttributeInteractionInfo); + Map writeThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatControlSequenceOfOperationCommandParams.put( - "value", - thermostatcontrolSequenceOfOperationCommandParameterInfo - ); - InteractionInfo writeThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeControlSequenceOfOperationAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatControlSequenceOfOperationCommandParams - ); - writeThermostatInteractionInfo.put("writeControlSequenceOfOperationAttribute", writeThermostatControlSequenceOfOperationAttributeInteractionInfo); - Map writeThermostatSystemModeCommandParams = new LinkedHashMap(); + "value", thermostatcontrolSequenceOfOperationCommandParameterInfo); + InteractionInfo writeThermostatControlSequenceOfOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeControlSequenceOfOperationAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatControlSequenceOfOperationCommandParams); + writeThermostatInteractionInfo.put( + "writeControlSequenceOfOperationAttribute", + writeThermostatControlSequenceOfOperationAttributeInteractionInfo); + Map writeThermostatSystemModeCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatsystemModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeThermostatSystemModeCommandParams.put( - "value", - thermostatsystemModeCommandParameterInfo - ); - InteractionInfo writeThermostatSystemModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeSystemModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatSystemModeCommandParams - ); - writeThermostatInteractionInfo.put("writeSystemModeAttribute", writeThermostatSystemModeAttributeInteractionInfo); - Map writeThermostatTemperatureSetpointHoldCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeThermostatSystemModeCommandParams.put("value", thermostatsystemModeCommandParameterInfo); + InteractionInfo writeThermostatSystemModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeSystemModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatSystemModeCommandParams); + writeThermostatInteractionInfo.put( + "writeSystemModeAttribute", writeThermostatSystemModeAttributeInteractionInfo); + Map writeThermostatTemperatureSetpointHoldCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostattemperatureSetpointHoldCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatTemperatureSetpointHoldCommandParams.put( - "value", - thermostattemperatureSetpointHoldCommandParameterInfo - ); - InteractionInfo writeThermostatTemperatureSetpointHoldAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeTemperatureSetpointHoldAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatTemperatureSetpointHoldCommandParams - ); - writeThermostatInteractionInfo.put("writeTemperatureSetpointHoldAttribute", writeThermostatTemperatureSetpointHoldAttributeInteractionInfo); - Map writeThermostatTemperatureSetpointHoldDurationCommandParams = new LinkedHashMap(); + "value", thermostattemperatureSetpointHoldCommandParameterInfo); + InteractionInfo writeThermostatTemperatureSetpointHoldAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeTemperatureSetpointHoldAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatTemperatureSetpointHoldCommandParams); + writeThermostatInteractionInfo.put( + "writeTemperatureSetpointHoldAttribute", + writeThermostatTemperatureSetpointHoldAttributeInteractionInfo); + Map writeThermostatTemperatureSetpointHoldDurationCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostattemperatureSetpointHoldDurationCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatTemperatureSetpointHoldDurationCommandParams.put( - "value", - thermostattemperatureSetpointHoldDurationCommandParameterInfo - ); - InteractionInfo writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeTemperatureSetpointHoldDurationAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatTemperatureSetpointHoldDurationCommandParams - ); - writeThermostatInteractionInfo.put("writeTemperatureSetpointHoldDurationAttribute", writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); - Map writeThermostatThermostatProgrammingOperationModeCommandParams = new LinkedHashMap(); + "value", thermostattemperatureSetpointHoldDurationCommandParameterInfo); + InteractionInfo writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeTemperatureSetpointHoldDurationAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatTemperatureSetpointHoldDurationCommandParams); + writeThermostatInteractionInfo.put( + "writeTemperatureSetpointHoldDurationAttribute", + writeThermostatTemperatureSetpointHoldDurationAttributeInteractionInfo); + Map + writeThermostatThermostatProgrammingOperationModeCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatthermostatProgrammingOperationModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatThermostatProgrammingOperationModeCommandParams.put( - "value", - thermostatthermostatProgrammingOperationModeCommandParameterInfo - ); - InteractionInfo writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeThermostatProgrammingOperationModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatThermostatProgrammingOperationModeCommandParams - ); - writeThermostatInteractionInfo.put("writeThermostatProgrammingOperationModeAttribute", writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); - Map writeThermostatOccupiedSetbackCommandParams = new LinkedHashMap(); + "value", thermostatthermostatProgrammingOperationModeCommandParameterInfo); + InteractionInfo writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeThermostatProgrammingOperationModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatThermostatProgrammingOperationModeCommandParams); + writeThermostatInteractionInfo.put( + "writeThermostatProgrammingOperationModeAttribute", + writeThermostatThermostatProgrammingOperationModeAttributeInteractionInfo); + Map writeThermostatOccupiedSetbackCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatoccupiedSetbackCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatOccupiedSetbackCommandParams.put( - "value", - thermostatoccupiedSetbackCommandParameterInfo - ); - InteractionInfo writeThermostatOccupiedSetbackAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeOccupiedSetbackAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatOccupiedSetbackCommandParams - ); - writeThermostatInteractionInfo.put("writeOccupiedSetbackAttribute", writeThermostatOccupiedSetbackAttributeInteractionInfo); - Map writeThermostatUnoccupiedSetbackCommandParams = new LinkedHashMap(); + "value", thermostatoccupiedSetbackCommandParameterInfo); + InteractionInfo writeThermostatOccupiedSetbackAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeOccupiedSetbackAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatOccupiedSetbackCommandParams); + writeThermostatInteractionInfo.put( + "writeOccupiedSetbackAttribute", writeThermostatOccupiedSetbackAttributeInteractionInfo); + Map writeThermostatUnoccupiedSetbackCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatunoccupiedSetbackCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatUnoccupiedSetbackCommandParams.put( - "value", - thermostatunoccupiedSetbackCommandParameterInfo - ); - InteractionInfo writeThermostatUnoccupiedSetbackAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeUnoccupiedSetbackAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUnoccupiedSetbackCommandParams - ); - writeThermostatInteractionInfo.put("writeUnoccupiedSetbackAttribute", writeThermostatUnoccupiedSetbackAttributeInteractionInfo); - Map writeThermostatEmergencyHeatDeltaCommandParams = new LinkedHashMap(); + "value", thermostatunoccupiedSetbackCommandParameterInfo); + InteractionInfo writeThermostatUnoccupiedSetbackAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeUnoccupiedSetbackAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUnoccupiedSetbackCommandParams); + writeThermostatInteractionInfo.put( + "writeUnoccupiedSetbackAttribute", + writeThermostatUnoccupiedSetbackAttributeInteractionInfo); + Map writeThermostatEmergencyHeatDeltaCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatemergencyHeatDeltaCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatEmergencyHeatDeltaCommandParams.put( - "value", - thermostatemergencyHeatDeltaCommandParameterInfo - ); - InteractionInfo writeThermostatEmergencyHeatDeltaAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeEmergencyHeatDeltaAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatEmergencyHeatDeltaCommandParams - ); - writeThermostatInteractionInfo.put("writeEmergencyHeatDeltaAttribute", writeThermostatEmergencyHeatDeltaAttributeInteractionInfo); - Map writeThermostatACTypeCommandParams = new LinkedHashMap(); + "value", thermostatemergencyHeatDeltaCommandParameterInfo); + InteractionInfo writeThermostatEmergencyHeatDeltaAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeEmergencyHeatDeltaAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatEmergencyHeatDeltaCommandParams); + writeThermostatInteractionInfo.put( + "writeEmergencyHeatDeltaAttribute", + writeThermostatEmergencyHeatDeltaAttributeInteractionInfo); + Map writeThermostatACTypeCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACTypeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeThermostatACTypeCommandParams.put( - "value", - thermostatACTypeCommandParameterInfo - ); - InteractionInfo writeThermostatACTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACTypeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACTypeCommandParams - ); - writeThermostatInteractionInfo.put("writeACTypeAttribute", writeThermostatACTypeAttributeInteractionInfo); - Map writeThermostatACCapacityCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeThermostatACTypeCommandParams.put("value", thermostatACTypeCommandParameterInfo); + InteractionInfo writeThermostatACTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACTypeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACTypeCommandParams); + writeThermostatInteractionInfo.put( + "writeACTypeAttribute", writeThermostatACTypeAttributeInteractionInfo); + Map writeThermostatACCapacityCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACCapacityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeThermostatACCapacityCommandParams.put( - "value", - thermostatACCapacityCommandParameterInfo - ); - InteractionInfo writeThermostatACCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACCapacityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACCapacityCommandParams - ); - writeThermostatInteractionInfo.put("writeACCapacityAttribute", writeThermostatACCapacityAttributeInteractionInfo); - Map writeThermostatACRefrigerantTypeCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeThermostatACCapacityCommandParams.put("value", thermostatACCapacityCommandParameterInfo); + InteractionInfo writeThermostatACCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACCapacityAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACCapacityCommandParams); + writeThermostatInteractionInfo.put( + "writeACCapacityAttribute", writeThermostatACCapacityAttributeInteractionInfo); + Map writeThermostatACRefrigerantTypeCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACRefrigerantTypeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatACRefrigerantTypeCommandParams.put( - "value", - thermostatACRefrigerantTypeCommandParameterInfo - ); - InteractionInfo writeThermostatACRefrigerantTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACRefrigerantTypeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACRefrigerantTypeCommandParams - ); - writeThermostatInteractionInfo.put("writeACRefrigerantTypeAttribute", writeThermostatACRefrigerantTypeAttributeInteractionInfo); - Map writeThermostatACCompressorTypeCommandParams = new LinkedHashMap(); + "value", thermostatACRefrigerantTypeCommandParameterInfo); + InteractionInfo writeThermostatACRefrigerantTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACRefrigerantTypeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACRefrigerantTypeCommandParams); + writeThermostatInteractionInfo.put( + "writeACRefrigerantTypeAttribute", + writeThermostatACRefrigerantTypeAttributeInteractionInfo); + Map writeThermostatACCompressorTypeCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACCompressorTypeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatACCompressorTypeCommandParams.put( - "value", - thermostatACCompressorTypeCommandParameterInfo - ); - InteractionInfo writeThermostatACCompressorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACCompressorTypeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACCompressorTypeCommandParams - ); - writeThermostatInteractionInfo.put("writeACCompressorTypeAttribute", writeThermostatACCompressorTypeAttributeInteractionInfo); - Map writeThermostatACErrorCodeCommandParams = new LinkedHashMap(); + "value", thermostatACCompressorTypeCommandParameterInfo); + InteractionInfo writeThermostatACCompressorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACCompressorTypeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACCompressorTypeCommandParams); + writeThermostatInteractionInfo.put( + "writeACCompressorTypeAttribute", writeThermostatACCompressorTypeAttributeInteractionInfo); + Map writeThermostatACErrorCodeCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACErrorCodeCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeThermostatACErrorCodeCommandParams.put( - "value", - thermostatACErrorCodeCommandParameterInfo - ); - InteractionInfo writeThermostatACErrorCodeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACErrorCodeAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACErrorCodeCommandParams - ); - writeThermostatInteractionInfo.put("writeACErrorCodeAttribute", writeThermostatACErrorCodeAttributeInteractionInfo); - Map writeThermostatACLouverPositionCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeThermostatACErrorCodeCommandParams.put("value", thermostatACErrorCodeCommandParameterInfo); + InteractionInfo writeThermostatACErrorCodeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACErrorCodeAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACErrorCodeCommandParams); + writeThermostatInteractionInfo.put( + "writeACErrorCodeAttribute", writeThermostatACErrorCodeAttributeInteractionInfo); + Map writeThermostatACLouverPositionCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACLouverPositionCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatACLouverPositionCommandParams.put( - "value", - thermostatACLouverPositionCommandParameterInfo - ); - InteractionInfo writeThermostatACLouverPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACLouverPositionAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACLouverPositionCommandParams - ); - writeThermostatInteractionInfo.put("writeACLouverPositionAttribute", writeThermostatACLouverPositionAttributeInteractionInfo); - Map writeThermostatACCapacityformatCommandParams = new LinkedHashMap(); + "value", thermostatACLouverPositionCommandParameterInfo); + InteractionInfo writeThermostatACLouverPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACLouverPositionAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACLouverPositionCommandParams); + writeThermostatInteractionInfo.put( + "writeACLouverPositionAttribute", writeThermostatACLouverPositionAttributeInteractionInfo); + Map writeThermostatACCapacityformatCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatACCapacityformatCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatACCapacityformatCommandParams.put( - "value", - thermostatACCapacityformatCommandParameterInfo - ); - InteractionInfo writeThermostatACCapacityformatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).writeACCapacityformatAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatACCapacityformatCommandParams - ); - writeThermostatInteractionInfo.put("writeACCapacityformatAttribute", writeThermostatACCapacityformatAttributeInteractionInfo); + "value", thermostatACCapacityformatCommandParameterInfo); + InteractionInfo writeThermostatACCapacityformatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .writeACCapacityformatAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatACCapacityformatCommandParams); + writeThermostatInteractionInfo.put( + "writeACCapacityformatAttribute", writeThermostatACCapacityformatAttributeInteractionInfo); writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); Map writeFanControlInteractionInfo = new LinkedHashMap<>(); - Map writeFanControlFanModeCommandParams = new LinkedHashMap(); + Map writeFanControlFanModeCommandParams = + new LinkedHashMap(); CommandParameterInfo fanControlfanModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeFanControlFanModeCommandParams.put( - "value", - fanControlfanModeCommandParameterInfo - ); - InteractionInfo writeFanControlFanModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).writeFanModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlFanModeCommandParams - ); - writeFanControlInteractionInfo.put("writeFanModeAttribute", writeFanControlFanModeAttributeInteractionInfo); - Map writeFanControlFanModeSequenceCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeFanControlFanModeCommandParams.put("value", fanControlfanModeCommandParameterInfo); + InteractionInfo writeFanControlFanModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .writeFanModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlFanModeCommandParams); + writeFanControlInteractionInfo.put( + "writeFanModeAttribute", writeFanControlFanModeAttributeInteractionInfo); + Map writeFanControlFanModeSequenceCommandParams = + new LinkedHashMap(); CommandParameterInfo fanControlfanModeSequenceCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeFanControlFanModeSequenceCommandParams.put( - "value", - fanControlfanModeSequenceCommandParameterInfo - ); - InteractionInfo writeFanControlFanModeSequenceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).writeFanModeSequenceAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlFanModeSequenceCommandParams - ); - writeFanControlInteractionInfo.put("writeFanModeSequenceAttribute", writeFanControlFanModeSequenceAttributeInteractionInfo); - Map writeFanControlPercentSettingCommandParams = new LinkedHashMap(); + "value", fanControlfanModeSequenceCommandParameterInfo); + InteractionInfo writeFanControlFanModeSequenceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .writeFanModeSequenceAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlFanModeSequenceCommandParams); + writeFanControlInteractionInfo.put( + "writeFanModeSequenceAttribute", writeFanControlFanModeSequenceAttributeInteractionInfo); + Map writeFanControlPercentSettingCommandParams = + new LinkedHashMap(); CommandParameterInfo fanControlpercentSettingCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeFanControlPercentSettingCommandParams.put( - "value", - fanControlpercentSettingCommandParameterInfo - ); - InteractionInfo writeFanControlPercentSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).writePercentSettingAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlPercentSettingCommandParams - ); - writeFanControlInteractionInfo.put("writePercentSettingAttribute", writeFanControlPercentSettingAttributeInteractionInfo); - Map writeFanControlSpeedSettingCommandParams = new LinkedHashMap(); + "value", fanControlpercentSettingCommandParameterInfo); + InteractionInfo writeFanControlPercentSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .writePercentSettingAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlPercentSettingCommandParams); + writeFanControlInteractionInfo.put( + "writePercentSettingAttribute", writeFanControlPercentSettingAttributeInteractionInfo); + Map writeFanControlSpeedSettingCommandParams = + new LinkedHashMap(); CommandParameterInfo fanControlspeedSettingCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeFanControlSpeedSettingCommandParams.put( - "value", - fanControlspeedSettingCommandParameterInfo - ); - InteractionInfo writeFanControlSpeedSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).writeSpeedSettingAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlSpeedSettingCommandParams - ); - writeFanControlInteractionInfo.put("writeSpeedSettingAttribute", writeFanControlSpeedSettingAttributeInteractionInfo); - Map writeFanControlRockSettingCommandParams = new LinkedHashMap(); + "value", fanControlspeedSettingCommandParameterInfo); + InteractionInfo writeFanControlSpeedSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .writeSpeedSettingAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlSpeedSettingCommandParams); + writeFanControlInteractionInfo.put( + "writeSpeedSettingAttribute", writeFanControlSpeedSettingAttributeInteractionInfo); + Map writeFanControlRockSettingCommandParams = + new LinkedHashMap(); CommandParameterInfo fanControlrockSettingCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeFanControlRockSettingCommandParams.put( - "value", - fanControlrockSettingCommandParameterInfo - ); - InteractionInfo writeFanControlRockSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).writeRockSettingAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlRockSettingCommandParams - ); - writeFanControlInteractionInfo.put("writeRockSettingAttribute", writeFanControlRockSettingAttributeInteractionInfo); - Map writeFanControlWindSettingCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeFanControlRockSettingCommandParams.put("value", fanControlrockSettingCommandParameterInfo); + InteractionInfo writeFanControlRockSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .writeRockSettingAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlRockSettingCommandParams); + writeFanControlInteractionInfo.put( + "writeRockSettingAttribute", writeFanControlRockSettingAttributeInteractionInfo); + Map writeFanControlWindSettingCommandParams = + new LinkedHashMap(); CommandParameterInfo fanControlwindSettingCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeFanControlWindSettingCommandParams.put( - "value", - fanControlwindSettingCommandParameterInfo - ); - InteractionInfo writeFanControlWindSettingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FanControlCluster) cluster).writeWindSettingAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeFanControlWindSettingCommandParams - ); - writeFanControlInteractionInfo.put("writeWindSettingAttribute", writeFanControlWindSettingAttributeInteractionInfo); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeFanControlWindSettingCommandParams.put("value", fanControlwindSettingCommandParameterInfo); + InteractionInfo writeFanControlWindSettingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FanControlCluster) cluster) + .writeWindSettingAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeFanControlWindSettingCommandParams); + writeFanControlInteractionInfo.put( + "writeWindSettingAttribute", writeFanControlWindSettingAttributeInteractionInfo); writeAttributeMap.put("fanControl", writeFanControlInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams.put( - "value", - thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo - ); - InteractionInfo writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).writeTemperatureDisplayModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams - ); - writeThermostatUserInterfaceConfigurationInteractionInfo.put("writeTemperatureDisplayModeAttribute", writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); - Map writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = new LinkedHashMap(); + "value", thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo); + InteractionInfo + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .writeTemperatureDisplayModeAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); + writeThermostatUserInterfaceConfigurationInteractionInfo.put( + "writeTemperatureDisplayModeAttribute", + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo); + Map + writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams = + new LinkedHashMap(); CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams.put( - "value", - thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo - ); - InteractionInfo writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).writeKeypadLockoutAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams - ); - writeThermostatUserInterfaceConfigurationInteractionInfo.put("writeKeypadLockoutAttribute", writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); - Map writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + "value", thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo); + InteractionInfo writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .writeKeypadLockoutAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUserInterfaceConfigurationKeypadLockoutCommandParams); + writeThermostatUserInterfaceConfigurationInteractionInfo.put( + "writeKeypadLockoutAttribute", + writeThermostatUserInterfaceConfigurationKeypadLockoutAttributeInteractionInfo); + Map + writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams.put( "value", - thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo - ); - InteractionInfo writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).writeScheduleProgrammingVisibilityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams - ); - writeThermostatUserInterfaceConfigurationInteractionInfo.put("writeScheduleProgrammingVisibilityAttribute", writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - writeAttributeMap.put("thermostatUserInterfaceConfiguration", writeThermostatUserInterfaceConfigurationInteractionInfo); + thermostatUserInterfaceConfigurationscheduleProgrammingVisibilityCommandParameterInfo); + InteractionInfo + writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .writeScheduleProgrammingVisibilityAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityCommandParams); + writeThermostatUserInterfaceConfigurationInteractionInfo.put( + "writeScheduleProgrammingVisibilityAttribute", + writeThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + writeAttributeMap.put( + "thermostatUserInterfaceConfiguration", + writeThermostatUserInterfaceConfigurationInteractionInfo); Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlOptionsCommandParams = new LinkedHashMap(); + Map writeColorControlOptionsCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControloptionsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeColorControlOptionsCommandParams.put( - "value", - colorControloptionsCommandParameterInfo - ); - InteractionInfo writeColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeOptionsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlOptionsCommandParams - ); - writeColorControlInteractionInfo.put("writeOptionsAttribute", writeColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeColorControlOptionsCommandParams.put("value", colorControloptionsCommandParameterInfo); + InteractionInfo writeColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeOptionsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlOptionsCommandParams); + writeColorControlInteractionInfo.put( + "writeOptionsAttribute", writeColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlwhitePointXCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlWhitePointXCommandParams.put( - "value", - colorControlwhitePointXCommandParameterInfo - ); - InteractionInfo writeColorControlWhitePointXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeWhitePointXAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlWhitePointXCommandParams - ); - writeColorControlInteractionInfo.put("writeWhitePointXAttribute", writeColorControlWhitePointXAttributeInteractionInfo); - Map writeColorControlWhitePointYCommandParams = new LinkedHashMap(); + "value", colorControlwhitePointXCommandParameterInfo); + InteractionInfo writeColorControlWhitePointXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeWhitePointXAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlWhitePointXCommandParams); + writeColorControlInteractionInfo.put( + "writeWhitePointXAttribute", writeColorControlWhitePointXAttributeInteractionInfo); + Map writeColorControlWhitePointYCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlwhitePointYCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlWhitePointYCommandParams.put( - "value", - colorControlwhitePointYCommandParameterInfo - ); - InteractionInfo writeColorControlWhitePointYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeWhitePointYAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlWhitePointYCommandParams - ); - writeColorControlInteractionInfo.put("writeWhitePointYAttribute", writeColorControlWhitePointYAttributeInteractionInfo); - Map writeColorControlColorPointRXCommandParams = new LinkedHashMap(); + "value", colorControlwhitePointYCommandParameterInfo); + InteractionInfo writeColorControlWhitePointYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeWhitePointYAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlWhitePointYCommandParams); + writeColorControlInteractionInfo.put( + "writeWhitePointYAttribute", writeColorControlWhitePointYAttributeInteractionInfo); + Map writeColorControlColorPointRXCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointRXCommandParams.put( - "value", - colorControlcolorPointRXCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointRXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointRXAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointRXCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointRXAttribute", writeColorControlColorPointRXAttributeInteractionInfo); - Map writeColorControlColorPointRYCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointRXCommandParameterInfo); + InteractionInfo writeColorControlColorPointRXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointRXAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointRXCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointRXAttribute", writeColorControlColorPointRXAttributeInteractionInfo); + Map writeColorControlColorPointRYCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointRYCommandParams.put( - "value", - colorControlcolorPointRYCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointRYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointRYAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointRYCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointRYAttribute", writeColorControlColorPointRYAttributeInteractionInfo); - Map writeColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointRYCommandParameterInfo); + InteractionInfo writeColorControlColorPointRYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointRYAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointRYCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointRYAttribute", writeColorControlColorPointRYAttributeInteractionInfo); + Map writeColorControlColorPointRIntensityCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointRIntensityCommandParams.put( - "value", - colorControlcolorPointRIntensityCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointRIntensityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointRIntensityCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointRIntensityAttribute", writeColorControlColorPointRIntensityAttributeInteractionInfo); - Map writeColorControlColorPointGXCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointRIntensityCommandParameterInfo); + InteractionInfo writeColorControlColorPointRIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointRIntensityAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointRIntensityCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointRIntensityAttribute", + writeColorControlColorPointRIntensityAttributeInteractionInfo); + Map writeColorControlColorPointGXCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointGXCommandParams.put( - "value", - colorControlcolorPointGXCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointGXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointGXAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointGXCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointGXAttribute", writeColorControlColorPointGXAttributeInteractionInfo); - Map writeColorControlColorPointGYCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointGXCommandParameterInfo); + InteractionInfo writeColorControlColorPointGXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointGXAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointGXCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointGXAttribute", writeColorControlColorPointGXAttributeInteractionInfo); + Map writeColorControlColorPointGYCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointGYCommandParams.put( - "value", - colorControlcolorPointGYCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointGYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointGYAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointGYCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointGYAttribute", writeColorControlColorPointGYAttributeInteractionInfo); - Map writeColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointGYCommandParameterInfo); + InteractionInfo writeColorControlColorPointGYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointGYAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointGYCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointGYAttribute", writeColorControlColorPointGYAttributeInteractionInfo); + Map writeColorControlColorPointGIntensityCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointGIntensityCommandParams.put( - "value", - colorControlcolorPointGIntensityCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointGIntensityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointGIntensityCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointGIntensityAttribute", writeColorControlColorPointGIntensityAttributeInteractionInfo); - Map writeColorControlColorPointBXCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointGIntensityCommandParameterInfo); + InteractionInfo writeColorControlColorPointGIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointGIntensityAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointGIntensityCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointGIntensityAttribute", + writeColorControlColorPointGIntensityAttributeInteractionInfo); + Map writeColorControlColorPointBXCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointBXCommandParams.put( - "value", - colorControlcolorPointBXCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointBXAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointBXAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointBXCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointBXAttribute", writeColorControlColorPointBXAttributeInteractionInfo); - Map writeColorControlColorPointBYCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointBXCommandParameterInfo); + InteractionInfo writeColorControlColorPointBXAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointBXAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointBXCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointBXAttribute", writeColorControlColorPointBXAttributeInteractionInfo); + Map writeColorControlColorPointBYCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointBYCommandParams.put( - "value", - colorControlcolorPointBYCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointBYAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointBYAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointBYCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointBYAttribute", writeColorControlColorPointBYAttributeInteractionInfo); - Map writeColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointBYCommandParameterInfo); + InteractionInfo writeColorControlColorPointBYAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointBYAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointBYCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointBYAttribute", writeColorControlColorPointBYAttributeInteractionInfo); + Map writeColorControlColorPointBIntensityCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlColorPointBIntensityCommandParams.put( - "value", - colorControlcolorPointBIntensityCommandParameterInfo - ); - InteractionInfo writeColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorPointBIntensityAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorPointBIntensityCommandParams - ); - writeColorControlInteractionInfo.put("writeColorPointBIntensityAttribute", writeColorControlColorPointBIntensityAttributeInteractionInfo); - Map writeColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); + "value", colorControlcolorPointBIntensityCommandParameterInfo); + InteractionInfo writeColorControlColorPointBIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorPointBIntensityAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorPointBIntensityCommandParams); + writeColorControlInteractionInfo.put( + "writeColorPointBIntensityAttribute", + writeColorControlColorPointBIntensityAttributeInteractionInfo); + Map writeColorControlStartUpColorTemperatureMiredsCommandParams = + new LinkedHashMap(); CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeColorControlStartUpColorTemperatureMiredsCommandParams.put( - "value", - colorControlstartUpColorTemperatureMiredsCommandParameterInfo - ); - InteractionInfo writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeStartUpColorTemperatureMiredsAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlStartUpColorTemperatureMiredsCommandParams - ); - writeColorControlInteractionInfo.put("writeStartUpColorTemperatureMiredsAttribute", writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + "value", colorControlstartUpColorTemperatureMiredsCommandParameterInfo); + InteractionInfo writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeStartUpColorTemperatureMiredsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlStartUpColorTemperatureMiredsCommandParams); + writeColorControlInteractionInfo.put( + "writeStartUpColorTemperatureMiredsAttribute", + writeColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); Map writeBallastConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeBallastConfigurationMinLevelCommandParams = new LinkedHashMap(); + Map writeBallastConfigurationMinLevelCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationminLevelCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBallastConfigurationMinLevelCommandParams.put( - "value", - ballastConfigurationminLevelCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationMinLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeMinLevelAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationMinLevelCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeMinLevelAttribute", writeBallastConfigurationMinLevelAttributeInteractionInfo); - Map writeBallastConfigurationMaxLevelCommandParams = new LinkedHashMap(); + "value", ballastConfigurationminLevelCommandParameterInfo); + InteractionInfo writeBallastConfigurationMinLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeMinLevelAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationMinLevelCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeMinLevelAttribute", writeBallastConfigurationMinLevelAttributeInteractionInfo); + Map writeBallastConfigurationMaxLevelCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationmaxLevelCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBallastConfigurationMaxLevelCommandParams.put( - "value", - ballastConfigurationmaxLevelCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationMaxLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeMaxLevelAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationMaxLevelCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeMaxLevelAttribute", writeBallastConfigurationMaxLevelAttributeInteractionInfo); - Map writeBallastConfigurationIntrinsicBallastFactorCommandParams = new LinkedHashMap(); + "value", ballastConfigurationmaxLevelCommandParameterInfo); + InteractionInfo writeBallastConfigurationMaxLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeMaxLevelAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationMaxLevelCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeMaxLevelAttribute", writeBallastConfigurationMaxLevelAttributeInteractionInfo); + Map writeBallastConfigurationIntrinsicBallastFactorCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationintrinsicBallastFactorCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBallastConfigurationIntrinsicBallastFactorCommandParams.put( - "value", - ballastConfigurationintrinsicBallastFactorCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeIntrinsicBallastFactorAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationIntrinsicBallastFactorCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeIntrinsicBallastFactorAttribute", writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); - Map writeBallastConfigurationBallastFactorAdjustmentCommandParams = new LinkedHashMap(); + "value", ballastConfigurationintrinsicBallastFactorCommandParameterInfo); + InteractionInfo writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeIntrinsicBallastFactorAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationIntrinsicBallastFactorCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeIntrinsicBallastFactorAttribute", + writeBallastConfigurationIntrinsicBallastFactorAttributeInteractionInfo); + Map + writeBallastConfigurationBallastFactorAdjustmentCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationballastFactorAdjustmentCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBallastConfigurationBallastFactorAdjustmentCommandParams.put( - "value", - ballastConfigurationballastFactorAdjustmentCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeBallastFactorAdjustmentAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationBallastFactorAdjustmentCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeBallastFactorAdjustmentAttribute", writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); - Map writeBallastConfigurationLampTypeCommandParams = new LinkedHashMap(); + "value", ballastConfigurationballastFactorAdjustmentCommandParameterInfo); + InteractionInfo writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeBallastFactorAdjustmentAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationBallastFactorAdjustmentCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeBallastFactorAdjustmentAttribute", + writeBallastConfigurationBallastFactorAdjustmentAttributeInteractionInfo); + Map writeBallastConfigurationLampTypeCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampTypeCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBallastConfigurationLampTypeCommandParams.put( - "value", - ballastConfigurationlampTypeCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationLampTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeLampTypeAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampTypeCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeLampTypeAttribute", writeBallastConfigurationLampTypeAttributeInteractionInfo); - Map writeBallastConfigurationLampManufacturerCommandParams = new LinkedHashMap(); + "value", ballastConfigurationlampTypeCommandParameterInfo); + InteractionInfo writeBallastConfigurationLampTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeLampTypeAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampTypeCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeLampTypeAttribute", writeBallastConfigurationLampTypeAttributeInteractionInfo); + Map writeBallastConfigurationLampManufacturerCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampManufacturerCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeBallastConfigurationLampManufacturerCommandParams.put( - "value", - ballastConfigurationlampManufacturerCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationLampManufacturerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeLampManufacturerAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampManufacturerCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeLampManufacturerAttribute", writeBallastConfigurationLampManufacturerAttributeInteractionInfo); - Map writeBallastConfigurationLampRatedHoursCommandParams = new LinkedHashMap(); + "value", ballastConfigurationlampManufacturerCommandParameterInfo); + InteractionInfo writeBallastConfigurationLampManufacturerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeLampManufacturerAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampManufacturerCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeLampManufacturerAttribute", + writeBallastConfigurationLampManufacturerAttributeInteractionInfo); + Map writeBallastConfigurationLampRatedHoursCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampRatedHoursCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeBallastConfigurationLampRatedHoursCommandParams.put( - "value", - ballastConfigurationlampRatedHoursCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationLampRatedHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeLampRatedHoursAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampRatedHoursCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeLampRatedHoursAttribute", writeBallastConfigurationLampRatedHoursAttributeInteractionInfo); - Map writeBallastConfigurationLampBurnHoursCommandParams = new LinkedHashMap(); + "value", ballastConfigurationlampRatedHoursCommandParameterInfo); + InteractionInfo writeBallastConfigurationLampRatedHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeLampRatedHoursAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampRatedHoursCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeLampRatedHoursAttribute", + writeBallastConfigurationLampRatedHoursAttributeInteractionInfo); + Map writeBallastConfigurationLampBurnHoursCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampBurnHoursCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeBallastConfigurationLampBurnHoursCommandParams.put( - "value", - ballastConfigurationlampBurnHoursCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationLampBurnHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeLampBurnHoursAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampBurnHoursCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeLampBurnHoursAttribute", writeBallastConfigurationLampBurnHoursAttributeInteractionInfo); - Map writeBallastConfigurationLampAlarmModeCommandParams = new LinkedHashMap(); + "value", ballastConfigurationlampBurnHoursCommandParameterInfo); + InteractionInfo writeBallastConfigurationLampBurnHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeLampBurnHoursAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampBurnHoursCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeLampBurnHoursAttribute", + writeBallastConfigurationLampBurnHoursAttributeInteractionInfo); + Map writeBallastConfigurationLampAlarmModeCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampAlarmModeCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeBallastConfigurationLampAlarmModeCommandParams.put( - "value", - ballastConfigurationlampAlarmModeCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationLampAlarmModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeLampAlarmModeAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampAlarmModeCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeLampAlarmModeAttribute", writeBallastConfigurationLampAlarmModeAttributeInteractionInfo); - Map writeBallastConfigurationLampBurnHoursTripPointCommandParams = new LinkedHashMap(); + "value", ballastConfigurationlampAlarmModeCommandParameterInfo); + InteractionInfo writeBallastConfigurationLampAlarmModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeLampAlarmModeAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampAlarmModeCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeLampAlarmModeAttribute", + writeBallastConfigurationLampAlarmModeAttributeInteractionInfo); + Map writeBallastConfigurationLampBurnHoursTripPointCommandParams = + new LinkedHashMap(); CommandParameterInfo ballastConfigurationlampBurnHoursTripPointCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeBallastConfigurationLampBurnHoursTripPointCommandParams.put( - "value", - ballastConfigurationlampBurnHoursTripPointCommandParameterInfo - ); - InteractionInfo writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BallastConfigurationCluster) cluster).writeLampBurnHoursTripPointAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBallastConfigurationLampBurnHoursTripPointCommandParams - ); - writeBallastConfigurationInteractionInfo.put("writeLampBurnHoursTripPointAttribute", writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); + "value", ballastConfigurationlampBurnHoursTripPointCommandParameterInfo); + InteractionInfo writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BallastConfigurationCluster) cluster) + .writeLampBurnHoursTripPointAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBallastConfigurationLampBurnHoursTripPointCommandParams); + writeBallastConfigurationInteractionInfo.put( + "writeLampBurnHoursTripPointAttribute", + writeBallastConfigurationLampBurnHoursTripPointAttributeInteractionInfo); writeAttributeMap.put("ballastConfiguration", writeBallastConfigurationInteractionInfo); Map writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); @@ -2832,207 +2307,198 @@ public Map> getWriteAttributeMap() { writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); + Map + writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams = + new LinkedHashMap(); CommandParameterInfo occupancySensingPIROccupiedToUnoccupiedDelayCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams.put( - "value", - occupancySensingPIROccupiedToUnoccupiedDelayCommandParameterInfo - ); - InteractionInfo writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writePIROccupiedToUnoccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams - ); - writeOccupancySensingInteractionInfo.put("writePIROccupiedToUnoccupiedDelayAttribute", writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); + "value", occupancySensingPIROccupiedToUnoccupiedDelayCommandParameterInfo); + InteractionInfo writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writePIROccupiedToUnoccupiedDelayAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPIROccupiedToUnoccupiedDelayCommandParams); + writeOccupancySensingInteractionInfo.put( + "writePIROccupiedToUnoccupiedDelayAttribute", + writeOccupancySensingPIROccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map + writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams = + new LinkedHashMap(); CommandParameterInfo occupancySensingPIRUnoccupiedToOccupiedDelayCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams.put( - "value", - occupancySensingPIRUnoccupiedToOccupiedDelayCommandParameterInfo - ); - InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writePIRUnoccupiedToOccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams - ); - writeOccupancySensingInteractionInfo.put("writePIRUnoccupiedToOccupiedDelayAttribute", writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); + "value", occupancySensingPIRUnoccupiedToOccupiedDelayCommandParameterInfo); + InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writePIRUnoccupiedToOccupiedDelayAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPIRUnoccupiedToOccupiedDelayCommandParams); + writeOccupancySensingInteractionInfo.put( + "writePIRUnoccupiedToOccupiedDelayAttribute", + writeOccupancySensingPIRUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map + writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams = + new LinkedHashMap(); CommandParameterInfo occupancySensingPIRUnoccupiedToOccupiedThresholdCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams.put( - "value", - occupancySensingPIRUnoccupiedToOccupiedThresholdCommandParameterInfo - ); - InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writePIRUnoccupiedToOccupiedThresholdAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams - ); - writeOccupancySensingInteractionInfo.put("writePIRUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); + "value", occupancySensingPIRUnoccupiedToOccupiedThresholdCommandParameterInfo); + InteractionInfo writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writePIRUnoccupiedToOccupiedThresholdAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPIRUnoccupiedToOccupiedThresholdCommandParams); + writeOccupancySensingInteractionInfo.put( + "writePIRUnoccupiedToOccupiedThresholdAttribute", + writeOccupancySensingPIRUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map + writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams = + new LinkedHashMap(); CommandParameterInfo occupancySensingultrasonicOccupiedToUnoccupiedDelayCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams.put( - "value", - occupancySensingultrasonicOccupiedToUnoccupiedDelayCommandParameterInfo - ); - InteractionInfo writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writeUltrasonicOccupiedToUnoccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams - ); - writeOccupancySensingInteractionInfo.put("writeUltrasonicOccupiedToUnoccupiedDelayAttribute", writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); + "value", occupancySensingultrasonicOccupiedToUnoccupiedDelayCommandParameterInfo); + InteractionInfo + writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writeUltrasonicOccupiedToUnoccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayCommandParams); + writeOccupancySensingInteractionInfo.put( + "writeUltrasonicOccupiedToUnoccupiedDelayAttribute", + writeOccupancySensingUltrasonicOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map + writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams = + new LinkedHashMap(); CommandParameterInfo occupancySensingultrasonicUnoccupiedToOccupiedDelayCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams.put( - "value", - occupancySensingultrasonicUnoccupiedToOccupiedDelayCommandParameterInfo - ); - InteractionInfo writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writeUltrasonicUnoccupiedToOccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams - ); - writeOccupancySensingInteractionInfo.put("writeUltrasonicUnoccupiedToOccupiedDelayAttribute", writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); - CommandParameterInfo occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + "value", occupancySensingultrasonicUnoccupiedToOccupiedDelayCommandParameterInfo); + InteractionInfo + writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writeUltrasonicUnoccupiedToOccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayCommandParams); + writeOccupancySensingInteractionInfo.put( + "writeUltrasonicUnoccupiedToOccupiedDelayAttribute", + writeOccupancySensingUltrasonicUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map + writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams = + new LinkedHashMap(); + CommandParameterInfo + occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams.put( - "value", - occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo - ); - InteractionInfo writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writeUltrasonicUnoccupiedToOccupiedThresholdAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams - ); - writeOccupancySensingInteractionInfo.put("writeUltrasonicUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); - Map writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = new LinkedHashMap(); - CommandParameterInfo occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + "value", occupancySensingultrasonicUnoccupiedToOccupiedThresholdCommandParameterInfo); + InteractionInfo + writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writeUltrasonicUnoccupiedToOccupiedThresholdAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdCommandParams); + writeOccupancySensingInteractionInfo.put( + "writeUltrasonicUnoccupiedToOccupiedThresholdAttribute", + writeOccupancySensingUltrasonicUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + Map + writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams = + new LinkedHashMap(); + CommandParameterInfo + occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams.put( - "value", - occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo - ); - InteractionInfo writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writePhysicalContactOccupiedToUnoccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams - ); - writeOccupancySensingInteractionInfo.put("writePhysicalContactOccupiedToUnoccupiedDelayAttribute", writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); - Map writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = new LinkedHashMap(); - CommandParameterInfo occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + "value", occupancySensingphysicalContactOccupiedToUnoccupiedDelayCommandParameterInfo); + InteractionInfo + writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writePhysicalContactOccupiedToUnoccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayCommandParams); + writeOccupancySensingInteractionInfo.put( + "writePhysicalContactOccupiedToUnoccupiedDelayAttribute", + writeOccupancySensingPhysicalContactOccupiedToUnoccupiedDelayAttributeInteractionInfo); + Map + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams = + new LinkedHashMap(); + CommandParameterInfo + occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams.put( - "value", - occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo - ); - InteractionInfo writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writePhysicalContactUnoccupiedToOccupiedDelayAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams - ); - writeOccupancySensingInteractionInfo.put("writePhysicalContactUnoccupiedToOccupiedDelayAttribute", writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); - Map writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = new LinkedHashMap(); - CommandParameterInfo occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + "value", occupancySensingphysicalContactUnoccupiedToOccupiedDelayCommandParameterInfo); + InteractionInfo + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writePhysicalContactUnoccupiedToOccupiedDelayAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayCommandParams); + writeOccupancySensingInteractionInfo.put( + "writePhysicalContactUnoccupiedToOccupiedDelayAttribute", + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedDelayAttributeInteractionInfo); + Map + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams = + new LinkedHashMap(); + CommandParameterInfo + occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams.put( - "value", - occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo - ); - InteractionInfo writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).writePhysicalContactUnoccupiedToOccupiedThresholdAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams - ); - writeOccupancySensingInteractionInfo.put("writePhysicalContactUnoccupiedToOccupiedThresholdAttribute", writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); + "value", occupancySensingphysicalContactUnoccupiedToOccupiedThresholdCommandParameterInfo); + InteractionInfo + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .writePhysicalContactUnoccupiedToOccupiedThresholdAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdCommandParams); + writeOccupancySensingInteractionInfo.put( + "writePhysicalContactUnoccupiedToOccupiedThresholdAttribute", + writeOccupancySensingPhysicalContactUnoccupiedToOccupiedThresholdAttributeInteractionInfo); writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); @@ -3049,28 +2515,24 @@ public Map> getWriteAttributeMap() { Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeContentLauncherSupportedStreamingProtocolsCommandParams.put( - "value", - contentLaunchersupportedStreamingProtocolsCommandParameterInfo - ); - InteractionInfo writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).writeSupportedStreamingProtocolsAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeContentLauncherSupportedStreamingProtocolsCommandParams - ); - writeContentLauncherInteractionInfo.put("writeSupportedStreamingProtocolsAttribute", writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + "value", contentLaunchersupportedStreamingProtocolsCommandParameterInfo); + InteractionInfo writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .writeSupportedStreamingProtocolsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeContentLauncherSupportedStreamingProtocolsCommandParams); + writeContentLauncherInteractionInfo.put( + "writeSupportedStreamingProtocolsAttribute", + writeContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); @@ -3081,1814 +2543,1411 @@ public Map> getWriteAttributeMap() { Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = new LinkedHashMap(); - CommandParameterInfo electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + Map + writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams = + new LinkedHashMap(); + CommandParameterInfo + electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo = + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams.put( - "value", - electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeAverageRmsVoltageMeasurementPeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeAverageRmsVoltageMeasurementPeriodAttribute", writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); - Map writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = new LinkedHashMap(); + "value", electricalMeasurementaverageRmsVoltageMeasurementPeriodCommandParameterInfo); + InteractionInfo + writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeAverageRmsVoltageMeasurementPeriodAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeAverageRmsVoltageMeasurementPeriodAttribute", + writeElectricalMeasurementAverageRmsVoltageMeasurementPeriodAttributeInteractionInfo); + Map + writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementaverageRmsUnderVoltageCounterCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams.put( - "value", - electricalMeasurementaverageRmsUnderVoltageCounterCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeAverageRmsUnderVoltageCounterAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeAverageRmsUnderVoltageCounterAttribute", writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); - Map writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = new LinkedHashMap(); + "value", electricalMeasurementaverageRmsUnderVoltageCounterCommandParameterInfo); + InteractionInfo + writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeAverageRmsUnderVoltageCounterAttribute( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementAverageRmsUnderVoltageCounterCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeAverageRmsUnderVoltageCounterAttribute", + writeElectricalMeasurementAverageRmsUnderVoltageCounterAttributeInteractionInfo); + Map + writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsExtremeOverVoltagePeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams.put( - "value", - electricalMeasurementrmsExtremeOverVoltagePeriodCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsExtremeOverVoltagePeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeRmsExtremeOverVoltagePeriodAttribute", writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); - Map writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = new LinkedHashMap(); + "value", electricalMeasurementrmsExtremeOverVoltagePeriodCommandParameterInfo); + InteractionInfo writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeRmsExtremeOverVoltagePeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsExtremeOverVoltagePeriodCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeRmsExtremeOverVoltagePeriodAttribute", + writeElectricalMeasurementRmsExtremeOverVoltagePeriodAttributeInteractionInfo); + Map + writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsExtremeUnderVoltagePeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams.put( - "value", - electricalMeasurementrmsExtremeUnderVoltagePeriodCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsExtremeUnderVoltagePeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeRmsExtremeUnderVoltagePeriodAttribute", writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); - Map writeElectricalMeasurementRmsVoltageSagPeriodCommandParams = new LinkedHashMap(); + "value", electricalMeasurementrmsExtremeUnderVoltagePeriodCommandParameterInfo); + InteractionInfo writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeRmsExtremeUnderVoltagePeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsExtremeUnderVoltagePeriodCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeRmsExtremeUnderVoltagePeriodAttribute", + writeElectricalMeasurementRmsExtremeUnderVoltagePeriodAttributeInteractionInfo); + Map writeElectricalMeasurementRmsVoltageSagPeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsVoltageSagPeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementRmsVoltageSagPeriodCommandParams.put( - "value", - electricalMeasurementrmsVoltageSagPeriodCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsVoltageSagPeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsVoltageSagPeriodCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeRmsVoltageSagPeriodAttribute", writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); - Map writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams = new LinkedHashMap(); + "value", electricalMeasurementrmsVoltageSagPeriodCommandParameterInfo); + InteractionInfo writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeRmsVoltageSagPeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsVoltageSagPeriodCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeRmsVoltageSagPeriodAttribute", + writeElectricalMeasurementRmsVoltageSagPeriodAttributeInteractionInfo); + Map writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementrmsVoltageSwellPeriodCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams.put( - "value", - electricalMeasurementrmsVoltageSwellPeriodCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeRmsVoltageSwellPeriodAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeRmsVoltageSwellPeriodAttribute", writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); - Map writeElectricalMeasurementOverloadAlarmsMaskCommandParams = new LinkedHashMap(); + "value", electricalMeasurementrmsVoltageSwellPeriodCommandParameterInfo); + InteractionInfo writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeRmsVoltageSwellPeriodAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementRmsVoltageSwellPeriodCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeRmsVoltageSwellPeriodAttribute", + writeElectricalMeasurementRmsVoltageSwellPeriodAttributeInteractionInfo); + Map writeElectricalMeasurementOverloadAlarmsMaskCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementoverloadAlarmsMaskCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementOverloadAlarmsMaskCommandParams.put( - "value", - electricalMeasurementoverloadAlarmsMaskCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeOverloadAlarmsMaskAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementOverloadAlarmsMaskCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeOverloadAlarmsMaskAttribute", writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); - Map writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams = new LinkedHashMap(); + "value", electricalMeasurementoverloadAlarmsMaskCommandParameterInfo); + InteractionInfo writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeOverloadAlarmsMaskAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementOverloadAlarmsMaskCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeOverloadAlarmsMaskAttribute", + writeElectricalMeasurementOverloadAlarmsMaskAttributeInteractionInfo); + Map writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams = + new LinkedHashMap(); CommandParameterInfo electricalMeasurementacOverloadAlarmsMaskCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams.put( - "value", - electricalMeasurementacOverloadAlarmsMaskCommandParameterInfo - ); - InteractionInfo writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).writeAcOverloadAlarmsMaskAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams - ); - writeElectricalMeasurementInteractionInfo.put("writeAcOverloadAlarmsMaskAttribute", writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); + "value", electricalMeasurementacOverloadAlarmsMaskCommandParameterInfo); + InteractionInfo writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .writeAcOverloadAlarmsMaskAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeElectricalMeasurementAcOverloadAlarmsMaskCommandParams); + writeElectricalMeasurementInteractionInfo.put( + "writeAcOverloadAlarmsMaskAttribute", + writeElectricalMeasurementAcOverloadAlarmsMaskAttributeInteractionInfo); writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); Map writeUnitTestingInteractionInfo = new LinkedHashMap<>(); - Map writeUnitTestingBooleanCommandParams = new LinkedHashMap(); + Map writeUnitTestingBooleanCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingbooleanCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); - writeUnitTestingBooleanCommandParams.put( - "value", - unitTestingbooleanCommandParameterInfo - ); - InteractionInfo writeUnitTestingBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBooleanCommandParams - ); - writeUnitTestingInteractionInfo.put("writeBooleanAttribute", writeUnitTestingBooleanAttributeInteractionInfo); - Map writeUnitTestingBitmap8CommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Boolean.class, Boolean.class); + writeUnitTestingBooleanCommandParams.put("value", unitTestingbooleanCommandParameterInfo); + InteractionInfo writeUnitTestingBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBooleanCommandParams); + writeUnitTestingInteractionInfo.put( + "writeBooleanAttribute", writeUnitTestingBooleanAttributeInteractionInfo); + Map writeUnitTestingBitmap8CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingbitmap8CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingBitmap8CommandParams.put( - "value", - unitTestingbitmap8CommandParameterInfo - ); - InteractionInfo writeUnitTestingBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap8CommandParams - ); - writeUnitTestingInteractionInfo.put("writeBitmap8Attribute", writeUnitTestingBitmap8AttributeInteractionInfo); - Map writeUnitTestingBitmap16CommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingBitmap8CommandParams.put("value", unitTestingbitmap8CommandParameterInfo); + InteractionInfo writeUnitTestingBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap8CommandParams); + writeUnitTestingInteractionInfo.put( + "writeBitmap8Attribute", writeUnitTestingBitmap8AttributeInteractionInfo); + Map writeUnitTestingBitmap16CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingbitmap16CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingBitmap16CommandParams.put( - "value", - unitTestingbitmap16CommandParameterInfo - ); - InteractionInfo writeUnitTestingBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap16CommandParams - ); - writeUnitTestingInteractionInfo.put("writeBitmap16Attribute", writeUnitTestingBitmap16AttributeInteractionInfo); - Map writeUnitTestingBitmap32CommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingBitmap16CommandParams.put("value", unitTestingbitmap16CommandParameterInfo); + InteractionInfo writeUnitTestingBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap16CommandParams); + writeUnitTestingInteractionInfo.put( + "writeBitmap16Attribute", writeUnitTestingBitmap16AttributeInteractionInfo); + Map writeUnitTestingBitmap32CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingbitmap32CommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingBitmap32CommandParams.put( - "value", - unitTestingbitmap32CommandParameterInfo - ); - InteractionInfo writeUnitTestingBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap32CommandParams - ); - writeUnitTestingInteractionInfo.put("writeBitmap32Attribute", writeUnitTestingBitmap32AttributeInteractionInfo); - Map writeUnitTestingBitmap64CommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingBitmap32CommandParams.put("value", unitTestingbitmap32CommandParameterInfo); + InteractionInfo writeUnitTestingBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap32CommandParams); + writeUnitTestingInteractionInfo.put( + "writeBitmap32Attribute", writeUnitTestingBitmap32AttributeInteractionInfo); + Map writeUnitTestingBitmap64CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingbitmap64CommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingBitmap64CommandParams.put( - "value", - unitTestingbitmap64CommandParameterInfo - ); - InteractionInfo writeUnitTestingBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingBitmap64CommandParams - ); - writeUnitTestingInteractionInfo.put("writeBitmap64Attribute", writeUnitTestingBitmap64AttributeInteractionInfo); - Map writeUnitTestingInt8uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingBitmap64CommandParams.put("value", unitTestingbitmap64CommandParameterInfo); + InteractionInfo writeUnitTestingBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingBitmap64CommandParams); + writeUnitTestingInteractionInfo.put( + "writeBitmap64Attribute", writeUnitTestingBitmap64AttributeInteractionInfo); + Map writeUnitTestingInt8uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint8uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingInt8uCommandParams.put( - "value", - unitTestingint8uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt8uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt8uAttribute", writeUnitTestingInt8uAttributeInteractionInfo); - Map writeUnitTestingInt16uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingInt8uCommandParams.put("value", unitTestingint8uCommandParameterInfo); + InteractionInfo writeUnitTestingInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt8uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt8uAttribute", writeUnitTestingInt8uAttributeInteractionInfo); + Map writeUnitTestingInt16uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint16uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingInt16uCommandParams.put( - "value", - unitTestingint16uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt16uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt16uAttribute", writeUnitTestingInt16uAttributeInteractionInfo); - Map writeUnitTestingInt24uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingInt16uCommandParams.put("value", unitTestingint16uCommandParameterInfo); + InteractionInfo writeUnitTestingInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt16uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt16uAttribute", writeUnitTestingInt16uAttributeInteractionInfo); + Map writeUnitTestingInt24uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint24uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt24uCommandParams.put( - "value", - unitTestingint24uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt24uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt24uAttribute", writeUnitTestingInt24uAttributeInteractionInfo); - Map writeUnitTestingInt32uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt24uCommandParams.put("value", unitTestingint24uCommandParameterInfo); + InteractionInfo writeUnitTestingInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt24uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt24uAttribute", writeUnitTestingInt24uAttributeInteractionInfo); + Map writeUnitTestingInt32uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint32uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt32uCommandParams.put( - "value", - unitTestingint32uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt32uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt32uAttribute", writeUnitTestingInt32uAttributeInteractionInfo); - Map writeUnitTestingInt40uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt32uCommandParams.put("value", unitTestingint32uCommandParameterInfo); + InteractionInfo writeUnitTestingInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt32uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt32uAttribute", writeUnitTestingInt32uAttributeInteractionInfo); + Map writeUnitTestingInt40uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint40uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt40uCommandParams.put( - "value", - unitTestingint40uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt40uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt40uAttribute", writeUnitTestingInt40uAttributeInteractionInfo); - Map writeUnitTestingInt48uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt40uCommandParams.put("value", unitTestingint40uCommandParameterInfo); + InteractionInfo writeUnitTestingInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt40uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt40uAttribute", writeUnitTestingInt40uAttributeInteractionInfo); + Map writeUnitTestingInt48uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint48uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt48uCommandParams.put( - "value", - unitTestingint48uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt48uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt48uAttribute", writeUnitTestingInt48uAttributeInteractionInfo); - Map writeUnitTestingInt56uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt48uCommandParams.put("value", unitTestingint48uCommandParameterInfo); + InteractionInfo writeUnitTestingInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt48uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt48uAttribute", writeUnitTestingInt48uAttributeInteractionInfo); + Map writeUnitTestingInt56uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint56uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt56uCommandParams.put( - "value", - unitTestingint56uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt56uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt56uAttribute", writeUnitTestingInt56uAttributeInteractionInfo); - Map writeUnitTestingInt64uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt56uCommandParams.put("value", unitTestingint56uCommandParameterInfo); + InteractionInfo writeUnitTestingInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt56uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt56uAttribute", writeUnitTestingInt56uAttributeInteractionInfo); + Map writeUnitTestingInt64uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint64uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt64uCommandParams.put( - "value", - unitTestingint64uCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt64uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt64uAttribute", writeUnitTestingInt64uAttributeInteractionInfo); - Map writeUnitTestingInt8sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt64uCommandParams.put("value", unitTestingint64uCommandParameterInfo); + InteractionInfo writeUnitTestingInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt64uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt64uAttribute", writeUnitTestingInt64uAttributeInteractionInfo); + Map writeUnitTestingInt8sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint8sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingInt8sCommandParams.put( - "value", - unitTestingint8sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt8sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt8sAttribute", writeUnitTestingInt8sAttributeInteractionInfo); - Map writeUnitTestingInt16sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingInt8sCommandParams.put("value", unitTestingint8sCommandParameterInfo); + InteractionInfo writeUnitTestingInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt8sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt8sAttribute", writeUnitTestingInt8sAttributeInteractionInfo); + Map writeUnitTestingInt16sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint16sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingInt16sCommandParams.put( - "value", - unitTestingint16sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt16sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt16sAttribute", writeUnitTestingInt16sAttributeInteractionInfo); - Map writeUnitTestingInt24sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingInt16sCommandParams.put("value", unitTestingint16sCommandParameterInfo); + InteractionInfo writeUnitTestingInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt16sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt16sAttribute", writeUnitTestingInt16sAttributeInteractionInfo); + Map writeUnitTestingInt24sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint24sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt24sCommandParams.put( - "value", - unitTestingint24sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt24sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt24sAttribute", writeUnitTestingInt24sAttributeInteractionInfo); - Map writeUnitTestingInt32sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt24sCommandParams.put("value", unitTestingint24sCommandParameterInfo); + InteractionInfo writeUnitTestingInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt24sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt24sAttribute", writeUnitTestingInt24sAttributeInteractionInfo); + Map writeUnitTestingInt32sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint32sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt32sCommandParams.put( - "value", - unitTestingint32sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt32sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt32sAttribute", writeUnitTestingInt32sAttributeInteractionInfo); - Map writeUnitTestingInt40sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt32sCommandParams.put("value", unitTestingint32sCommandParameterInfo); + InteractionInfo writeUnitTestingInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt32sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt32sAttribute", writeUnitTestingInt32sAttributeInteractionInfo); + Map writeUnitTestingInt40sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint40sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt40sCommandParams.put( - "value", - unitTestingint40sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt40sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt40sAttribute", writeUnitTestingInt40sAttributeInteractionInfo); - Map writeUnitTestingInt48sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt40sCommandParams.put("value", unitTestingint40sCommandParameterInfo); + InteractionInfo writeUnitTestingInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt40sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt40sAttribute", writeUnitTestingInt40sAttributeInteractionInfo); + Map writeUnitTestingInt48sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint48sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt48sCommandParams.put( - "value", - unitTestingint48sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt48sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt48sAttribute", writeUnitTestingInt48sAttributeInteractionInfo); - Map writeUnitTestingInt56sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt48sCommandParams.put("value", unitTestingint48sCommandParameterInfo); + InteractionInfo writeUnitTestingInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt48sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt48sAttribute", writeUnitTestingInt48sAttributeInteractionInfo); + Map writeUnitTestingInt56sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint56sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt56sCommandParams.put( - "value", - unitTestingint56sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt56sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt56sAttribute", writeUnitTestingInt56sAttributeInteractionInfo); - Map writeUnitTestingInt64sCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt56sCommandParams.put("value", unitTestingint56sCommandParameterInfo); + InteractionInfo writeUnitTestingInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt56sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt56sAttribute", writeUnitTestingInt56sAttributeInteractionInfo); + Map writeUnitTestingInt64sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingint64sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingInt64sCommandParams.put( - "value", - unitTestingint64sCommandParameterInfo - ); - InteractionInfo writeUnitTestingInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingInt64sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeInt64sAttribute", writeUnitTestingInt64sAttributeInteractionInfo); - Map writeUnitTestingEnum8CommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingInt64sCommandParams.put("value", unitTestingint64sCommandParameterInfo); + InteractionInfo writeUnitTestingInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingInt64sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeInt64sAttribute", writeUnitTestingInt64sAttributeInteractionInfo); + Map writeUnitTestingEnum8CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingenum8CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingEnum8CommandParams.put( - "value", - unitTestingenum8CommandParameterInfo - ); - InteractionInfo writeUnitTestingEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEnum8CommandParams - ); - writeUnitTestingInteractionInfo.put("writeEnum8Attribute", writeUnitTestingEnum8AttributeInteractionInfo); - Map writeUnitTestingEnum16CommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingEnum8CommandParams.put("value", unitTestingenum8CommandParameterInfo); + InteractionInfo writeUnitTestingEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEnum8CommandParams); + writeUnitTestingInteractionInfo.put( + "writeEnum8Attribute", writeUnitTestingEnum8AttributeInteractionInfo); + Map writeUnitTestingEnum16CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingenum16CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingEnum16CommandParams.put( - "value", - unitTestingenum16CommandParameterInfo - ); - InteractionInfo writeUnitTestingEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEnum16CommandParams - ); - writeUnitTestingInteractionInfo.put("writeEnum16Attribute", writeUnitTestingEnum16AttributeInteractionInfo); - Map writeUnitTestingFloatSingleCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingEnum16CommandParams.put("value", unitTestingenum16CommandParameterInfo); + InteractionInfo writeUnitTestingEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEnum16CommandParams); + writeUnitTestingInteractionInfo.put( + "writeEnum16Attribute", writeUnitTestingEnum16AttributeInteractionInfo); + Map writeUnitTestingFloatSingleCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingfloatSingleCommandParameterInfo = - new CommandParameterInfo( - "value", - Float.class, - Float.class - ); + new CommandParameterInfo("value", Float.class, Float.class); writeUnitTestingFloatSingleCommandParams.put( - "value", - unitTestingfloatSingleCommandParameterInfo - ); - InteractionInfo writeUnitTestingFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingFloatSingleCommandParams - ); - writeUnitTestingInteractionInfo.put("writeFloatSingleAttribute", writeUnitTestingFloatSingleAttributeInteractionInfo); - Map writeUnitTestingFloatDoubleCommandParams = new LinkedHashMap(); + "value", unitTestingfloatSingleCommandParameterInfo); + InteractionInfo writeUnitTestingFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingFloatSingleCommandParams); + writeUnitTestingInteractionInfo.put( + "writeFloatSingleAttribute", writeUnitTestingFloatSingleAttributeInteractionInfo); + Map writeUnitTestingFloatDoubleCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingfloatDoubleCommandParameterInfo = - new CommandParameterInfo( - "value", - Double.class, - Double.class - ); + new CommandParameterInfo("value", Double.class, Double.class); writeUnitTestingFloatDoubleCommandParams.put( - "value", - unitTestingfloatDoubleCommandParameterInfo - ); - InteractionInfo writeUnitTestingFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingFloatDoubleCommandParams - ); - writeUnitTestingInteractionInfo.put("writeFloatDoubleAttribute", writeUnitTestingFloatDoubleAttributeInteractionInfo); - Map writeUnitTestingOctetStringCommandParams = new LinkedHashMap(); + "value", unitTestingfloatDoubleCommandParameterInfo); + InteractionInfo writeUnitTestingFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingFloatDoubleCommandParams); + writeUnitTestingInteractionInfo.put( + "writeFloatDoubleAttribute", writeUnitTestingFloatDoubleAttributeInteractionInfo); + Map writeUnitTestingOctetStringCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingoctetStringCommandParameterInfo = - new CommandParameterInfo( - "value", - byte[].class, - byte[].class - ); + new CommandParameterInfo("value", byte[].class, byte[].class); writeUnitTestingOctetStringCommandParams.put( - "value", - unitTestingoctetStringCommandParameterInfo - ); - InteractionInfo writeUnitTestingOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingOctetStringCommandParams - ); - writeUnitTestingInteractionInfo.put("writeOctetStringAttribute", writeUnitTestingOctetStringAttributeInteractionInfo); - Map writeUnitTestingLongOctetStringCommandParams = new LinkedHashMap(); + "value", unitTestingoctetStringCommandParameterInfo); + InteractionInfo writeUnitTestingOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingOctetStringCommandParams); + writeUnitTestingInteractionInfo.put( + "writeOctetStringAttribute", writeUnitTestingOctetStringAttributeInteractionInfo); + Map writeUnitTestingLongOctetStringCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestinglongOctetStringCommandParameterInfo = - new CommandParameterInfo( - "value", - byte[].class, - byte[].class - ); + new CommandParameterInfo("value", byte[].class, byte[].class); writeUnitTestingLongOctetStringCommandParams.put( - "value", - unitTestinglongOctetStringCommandParameterInfo - ); - InteractionInfo writeUnitTestingLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingLongOctetStringCommandParams - ); - writeUnitTestingInteractionInfo.put("writeLongOctetStringAttribute", writeUnitTestingLongOctetStringAttributeInteractionInfo); - Map writeUnitTestingCharStringCommandParams = new LinkedHashMap(); + "value", unitTestinglongOctetStringCommandParameterInfo); + InteractionInfo writeUnitTestingLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingLongOctetStringCommandParams); + writeUnitTestingInteractionInfo.put( + "writeLongOctetStringAttribute", writeUnitTestingLongOctetStringAttributeInteractionInfo); + Map writeUnitTestingCharStringCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingcharStringCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); - writeUnitTestingCharStringCommandParams.put( - "value", - unitTestingcharStringCommandParameterInfo - ); - InteractionInfo writeUnitTestingCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeCharStringAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingCharStringCommandParams - ); - writeUnitTestingInteractionInfo.put("writeCharStringAttribute", writeUnitTestingCharStringAttributeInteractionInfo); - Map writeUnitTestingLongCharStringCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", String.class, String.class); + writeUnitTestingCharStringCommandParams.put("value", unitTestingcharStringCommandParameterInfo); + InteractionInfo writeUnitTestingCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingCharStringCommandParams); + writeUnitTestingInteractionInfo.put( + "writeCharStringAttribute", writeUnitTestingCharStringAttributeInteractionInfo); + Map writeUnitTestingLongCharStringCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestinglongCharStringCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeUnitTestingLongCharStringCommandParams.put( - "value", - unitTestinglongCharStringCommandParameterInfo - ); - InteractionInfo writeUnitTestingLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeLongCharStringAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingLongCharStringCommandParams - ); - writeUnitTestingInteractionInfo.put("writeLongCharStringAttribute", writeUnitTestingLongCharStringAttributeInteractionInfo); - Map writeUnitTestingEpochUsCommandParams = new LinkedHashMap(); + "value", unitTestinglongCharStringCommandParameterInfo); + InteractionInfo writeUnitTestingLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeLongCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingLongCharStringCommandParams); + writeUnitTestingInteractionInfo.put( + "writeLongCharStringAttribute", writeUnitTestingLongCharStringAttributeInteractionInfo); + Map writeUnitTestingEpochUsCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingepochUsCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingEpochUsCommandParams.put( - "value", - unitTestingepochUsCommandParameterInfo - ); - InteractionInfo writeUnitTestingEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeEpochUsAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEpochUsCommandParams - ); - writeUnitTestingInteractionInfo.put("writeEpochUsAttribute", writeUnitTestingEpochUsAttributeInteractionInfo); - Map writeUnitTestingEpochSCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingEpochUsCommandParams.put("value", unitTestingepochUsCommandParameterInfo); + InteractionInfo writeUnitTestingEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeEpochUsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEpochUsCommandParams); + writeUnitTestingInteractionInfo.put( + "writeEpochUsAttribute", writeUnitTestingEpochUsAttributeInteractionInfo); + Map writeUnitTestingEpochSCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingepochSCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); - writeUnitTestingEpochSCommandParams.put( - "value", - unitTestingepochSCommandParameterInfo - ); - InteractionInfo writeUnitTestingEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeEpochSAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEpochSCommandParams - ); - writeUnitTestingInteractionInfo.put("writeEpochSAttribute", writeUnitTestingEpochSAttributeInteractionInfo); - Map writeUnitTestingVendorIdCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Long.class, Long.class); + writeUnitTestingEpochSCommandParams.put("value", unitTestingepochSCommandParameterInfo); + InteractionInfo writeUnitTestingEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeEpochSAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEpochSCommandParams); + writeUnitTestingInteractionInfo.put( + "writeEpochSAttribute", writeUnitTestingEpochSAttributeInteractionInfo); + Map writeUnitTestingVendorIdCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingvendorIdCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingVendorIdCommandParams.put( - "value", - unitTestingvendorIdCommandParameterInfo - ); - InteractionInfo writeUnitTestingVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeVendorIdAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingVendorIdCommandParams - ); - writeUnitTestingInteractionInfo.put("writeVendorIdAttribute", writeUnitTestingVendorIdAttributeInteractionInfo); - Map writeUnitTestingEnumAttrCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingVendorIdCommandParams.put("value", unitTestingvendorIdCommandParameterInfo); + InteractionInfo writeUnitTestingVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeVendorIdAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingVendorIdCommandParams); + writeUnitTestingInteractionInfo.put( + "writeVendorIdAttribute", writeUnitTestingVendorIdAttributeInteractionInfo); + Map writeUnitTestingEnumAttrCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingenumAttrCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); - writeUnitTestingEnumAttrCommandParams.put( - "value", - unitTestingenumAttrCommandParameterInfo - ); - InteractionInfo writeUnitTestingEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingEnumAttrCommandParams - ); - writeUnitTestingInteractionInfo.put("writeEnumAttrAttribute", writeUnitTestingEnumAttrAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + new CommandParameterInfo("value", Integer.class, Integer.class); + writeUnitTestingEnumAttrCommandParams.put("value", unitTestingenumAttrCommandParameterInfo); + InteractionInfo writeUnitTestingEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingEnumAttrCommandParams); + writeUnitTestingInteractionInfo.put( + "writeEnumAttrAttribute", writeUnitTestingEnumAttrAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingRangeRestrictedInt8uCommandParams.put( - "value", - unitTestingrangeRestrictedInt8uCommandParameterInfo - ); - InteractionInfo writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt8uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + "value", unitTestingrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt8uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeRangeRestrictedInt8uAttribute", + writeUnitTestingRangeRestrictedInt8uAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingRangeRestrictedInt8sCommandParams.put( - "value", - unitTestingrangeRestrictedInt8sCommandParameterInfo - ); - InteractionInfo writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt8sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + "value", unitTestingrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt8sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeRangeRestrictedInt8sAttribute", + writeUnitTestingRangeRestrictedInt8sAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingRangeRestrictedInt16uCommandParams.put( - "value", - unitTestingrangeRestrictedInt16uCommandParameterInfo - ); - InteractionInfo writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt16uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); - Map writeUnitTestingRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + "value", unitTestingrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt16uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeRangeRestrictedInt16uAttribute", + writeUnitTestingRangeRestrictedInt16uAttributeInteractionInfo); + Map writeUnitTestingRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingrangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingRangeRestrictedInt16sCommandParams.put( - "value", - unitTestingrangeRestrictedInt16sCommandParameterInfo - ); - InteractionInfo writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingRangeRestrictedInt16sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); - Map writeUnitTestingTimedWriteBooleanCommandParams = new LinkedHashMap(); + "value", unitTestingrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingRangeRestrictedInt16sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeRangeRestrictedInt16sAttribute", + writeUnitTestingRangeRestrictedInt16sAttributeInteractionInfo); + Map writeUnitTestingTimedWriteBooleanCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingtimedWriteBooleanCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeUnitTestingTimedWriteBooleanCommandParams.put( - "value", - unitTestingtimedWriteBooleanCommandParameterInfo - ); - InteractionInfo writeUnitTestingTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value"), 10000 - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingTimedWriteBooleanCommandParams - ); - writeUnitTestingInteractionInfo.put("writeTimedWriteBooleanAttribute", writeUnitTestingTimedWriteBooleanAttributeInteractionInfo); - Map writeUnitTestingGeneralErrorBooleanCommandParams = new LinkedHashMap(); + "value", unitTestingtimedWriteBooleanCommandParameterInfo); + InteractionInfo writeUnitTestingTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value"), + 10000); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingTimedWriteBooleanCommandParams); + writeUnitTestingInteractionInfo.put( + "writeTimedWriteBooleanAttribute", + writeUnitTestingTimedWriteBooleanAttributeInteractionInfo); + Map writeUnitTestingGeneralErrorBooleanCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestinggeneralErrorBooleanCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeUnitTestingGeneralErrorBooleanCommandParams.put( - "value", - unitTestinggeneralErrorBooleanCommandParameterInfo - ); - InteractionInfo writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingGeneralErrorBooleanCommandParams - ); - writeUnitTestingInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo); - Map writeUnitTestingClusterErrorBooleanCommandParams = new LinkedHashMap(); + "value", unitTestinggeneralErrorBooleanCommandParameterInfo); + InteractionInfo writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingGeneralErrorBooleanCommandParams); + writeUnitTestingInteractionInfo.put( + "writeGeneralErrorBooleanAttribute", + writeUnitTestingGeneralErrorBooleanAttributeInteractionInfo); + Map writeUnitTestingClusterErrorBooleanCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingclusterErrorBooleanCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeUnitTestingClusterErrorBooleanCommandParams.put( - "value", - unitTestingclusterErrorBooleanCommandParameterInfo - ); - InteractionInfo writeUnitTestingClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingClusterErrorBooleanCommandParams - ); - writeUnitTestingInteractionInfo.put("writeClusterErrorBooleanAttribute", writeUnitTestingClusterErrorBooleanAttributeInteractionInfo); - Map writeUnitTestingUnsupportedCommandParams = new LinkedHashMap(); + "value", unitTestingclusterErrorBooleanCommandParameterInfo); + InteractionInfo writeUnitTestingClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingClusterErrorBooleanCommandParams); + writeUnitTestingInteractionInfo.put( + "writeClusterErrorBooleanAttribute", + writeUnitTestingClusterErrorBooleanAttributeInteractionInfo); + Map writeUnitTestingUnsupportedCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingunsupportedCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeUnitTestingUnsupportedCommandParams.put( - "value", - unitTestingunsupportedCommandParameterInfo - ); - InteractionInfo writeUnitTestingUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeUnsupportedAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingUnsupportedCommandParams - ); - writeUnitTestingInteractionInfo.put("writeUnsupportedAttribute", writeUnitTestingUnsupportedAttributeInteractionInfo); - Map writeUnitTestingNullableBooleanCommandParams = new LinkedHashMap(); + "value", unitTestingunsupportedCommandParameterInfo); + InteractionInfo writeUnitTestingUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeUnsupportedAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingUnsupportedCommandParams); + writeUnitTestingInteractionInfo.put( + "writeUnsupportedAttribute", writeUnitTestingUnsupportedAttributeInteractionInfo); + Map writeUnitTestingNullableBooleanCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableBooleanCommandParameterInfo = - new CommandParameterInfo( - "value", - Boolean.class, - Boolean.class - ); + new CommandParameterInfo("value", Boolean.class, Boolean.class); writeUnitTestingNullableBooleanCommandParams.put( - "value", - unitTestingnullableBooleanCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBooleanCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableBooleanAttribute", writeUnitTestingNullableBooleanAttributeInteractionInfo); - Map writeUnitTestingNullableBitmap8CommandParams = new LinkedHashMap(); + "value", unitTestingnullableBooleanCommandParameterInfo); + InteractionInfo writeUnitTestingNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBooleanCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableBooleanAttribute", writeUnitTestingNullableBooleanAttributeInteractionInfo); + Map writeUnitTestingNullableBitmap8CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap8CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableBitmap8CommandParams.put( - "value", - unitTestingnullableBitmap8CommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap8CommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableBitmap8Attribute", writeUnitTestingNullableBitmap8AttributeInteractionInfo); - Map writeUnitTestingNullableBitmap16CommandParams = new LinkedHashMap(); + "value", unitTestingnullableBitmap8CommandParameterInfo); + InteractionInfo writeUnitTestingNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap8CommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableBitmap8Attribute", writeUnitTestingNullableBitmap8AttributeInteractionInfo); + Map writeUnitTestingNullableBitmap16CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap16CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableBitmap16CommandParams.put( - "value", - unitTestingnullableBitmap16CommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap16CommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableBitmap16Attribute", writeUnitTestingNullableBitmap16AttributeInteractionInfo); - Map writeUnitTestingNullableBitmap32CommandParams = new LinkedHashMap(); + "value", unitTestingnullableBitmap16CommandParameterInfo); + InteractionInfo writeUnitTestingNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap16CommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableBitmap16Attribute", writeUnitTestingNullableBitmap16AttributeInteractionInfo); + Map writeUnitTestingNullableBitmap32CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap32CommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableBitmap32CommandParams.put( - "value", - unitTestingnullableBitmap32CommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap32CommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableBitmap32Attribute", writeUnitTestingNullableBitmap32AttributeInteractionInfo); - Map writeUnitTestingNullableBitmap64CommandParams = new LinkedHashMap(); + "value", unitTestingnullableBitmap32CommandParameterInfo); + InteractionInfo writeUnitTestingNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap32CommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableBitmap32Attribute", writeUnitTestingNullableBitmap32AttributeInteractionInfo); + Map writeUnitTestingNullableBitmap64CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableBitmap64CommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableBitmap64CommandParams.put( - "value", - unitTestingnullableBitmap64CommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableBitmap64CommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableBitmap64Attribute", writeUnitTestingNullableBitmap64AttributeInteractionInfo); - Map writeUnitTestingNullableInt8uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableBitmap64CommandParameterInfo); + InteractionInfo writeUnitTestingNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableBitmap64CommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableBitmap64Attribute", writeUnitTestingNullableBitmap64AttributeInteractionInfo); + Map writeUnitTestingNullableInt8uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt8uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableInt8uCommandParams.put( - "value", - unitTestingnullableInt8uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt8uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt8uAttribute", writeUnitTestingNullableInt8uAttributeInteractionInfo); - Map writeUnitTestingNullableInt16uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt8uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt8uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt8uAttribute", writeUnitTestingNullableInt8uAttributeInteractionInfo); + Map writeUnitTestingNullableInt16uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt16uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableInt16uCommandParams.put( - "value", - unitTestingnullableInt16uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt16uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt16uAttribute", writeUnitTestingNullableInt16uAttributeInteractionInfo); - Map writeUnitTestingNullableInt24uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt16uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt16uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt16uAttribute", writeUnitTestingNullableInt16uAttributeInteractionInfo); + Map writeUnitTestingNullableInt24uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt24uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt24uCommandParams.put( - "value", - unitTestingnullableInt24uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt24uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt24uAttribute", writeUnitTestingNullableInt24uAttributeInteractionInfo); - Map writeUnitTestingNullableInt32uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt24uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt24uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt24uAttribute", writeUnitTestingNullableInt24uAttributeInteractionInfo); + Map writeUnitTestingNullableInt32uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt32uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt32uCommandParams.put( - "value", - unitTestingnullableInt32uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt32uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt32uAttribute", writeUnitTestingNullableInt32uAttributeInteractionInfo); - Map writeUnitTestingNullableInt40uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt32uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt32uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt32uAttribute", writeUnitTestingNullableInt32uAttributeInteractionInfo); + Map writeUnitTestingNullableInt40uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt40uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt40uCommandParams.put( - "value", - unitTestingnullableInt40uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt40uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt40uAttribute", writeUnitTestingNullableInt40uAttributeInteractionInfo); - Map writeUnitTestingNullableInt48uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt40uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt40uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt40uAttribute", writeUnitTestingNullableInt40uAttributeInteractionInfo); + Map writeUnitTestingNullableInt48uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt48uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt48uCommandParams.put( - "value", - unitTestingnullableInt48uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt48uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt48uAttribute", writeUnitTestingNullableInt48uAttributeInteractionInfo); - Map writeUnitTestingNullableInt56uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt48uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt48uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt48uAttribute", writeUnitTestingNullableInt48uAttributeInteractionInfo); + Map writeUnitTestingNullableInt56uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt56uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt56uCommandParams.put( - "value", - unitTestingnullableInt56uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt56uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt56uAttribute", writeUnitTestingNullableInt56uAttributeInteractionInfo); - Map writeUnitTestingNullableInt64uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt56uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt56uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt56uAttribute", writeUnitTestingNullableInt56uAttributeInteractionInfo); + Map writeUnitTestingNullableInt64uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt64uCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt64uCommandParams.put( - "value", - unitTestingnullableInt64uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt64uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt64uAttribute", writeUnitTestingNullableInt64uAttributeInteractionInfo); - Map writeUnitTestingNullableInt8sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt64uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt64uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt64uAttribute", writeUnitTestingNullableInt64uAttributeInteractionInfo); + Map writeUnitTestingNullableInt8sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt8sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableInt8sCommandParams.put( - "value", - unitTestingnullableInt8sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt8sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt8sAttribute", writeUnitTestingNullableInt8sAttributeInteractionInfo); - Map writeUnitTestingNullableInt16sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt8sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt8sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt8sAttribute", writeUnitTestingNullableInt8sAttributeInteractionInfo); + Map writeUnitTestingNullableInt16sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt16sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableInt16sCommandParams.put( - "value", - unitTestingnullableInt16sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt16sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt16sAttribute", writeUnitTestingNullableInt16sAttributeInteractionInfo); - Map writeUnitTestingNullableInt24sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt16sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt16sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt16sAttribute", writeUnitTestingNullableInt16sAttributeInteractionInfo); + Map writeUnitTestingNullableInt24sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt24sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt24sCommandParams.put( - "value", - unitTestingnullableInt24sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt24sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt24sAttribute", writeUnitTestingNullableInt24sAttributeInteractionInfo); - Map writeUnitTestingNullableInt32sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt24sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt24sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt24sAttribute", writeUnitTestingNullableInt24sAttributeInteractionInfo); + Map writeUnitTestingNullableInt32sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt32sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt32sCommandParams.put( - "value", - unitTestingnullableInt32sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt32sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt32sAttribute", writeUnitTestingNullableInt32sAttributeInteractionInfo); - Map writeUnitTestingNullableInt40sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt32sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt32sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt32sAttribute", writeUnitTestingNullableInt32sAttributeInteractionInfo); + Map writeUnitTestingNullableInt40sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt40sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt40sCommandParams.put( - "value", - unitTestingnullableInt40sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt40sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt40sAttribute", writeUnitTestingNullableInt40sAttributeInteractionInfo); - Map writeUnitTestingNullableInt48sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt40sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt40sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt40sAttribute", writeUnitTestingNullableInt40sAttributeInteractionInfo); + Map writeUnitTestingNullableInt48sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt48sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt48sCommandParams.put( - "value", - unitTestingnullableInt48sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt48sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt48sAttribute", writeUnitTestingNullableInt48sAttributeInteractionInfo); - Map writeUnitTestingNullableInt56sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt48sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt48sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt48sAttribute", writeUnitTestingNullableInt48sAttributeInteractionInfo); + Map writeUnitTestingNullableInt56sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt56sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt56sCommandParams.put( - "value", - unitTestingnullableInt56sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt56sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt56sAttribute", writeUnitTestingNullableInt56sAttributeInteractionInfo); - Map writeUnitTestingNullableInt64sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt56sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt56sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt56sAttribute", writeUnitTestingNullableInt56sAttributeInteractionInfo); + Map writeUnitTestingNullableInt64sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableInt64sCommandParameterInfo = - new CommandParameterInfo( - "value", - Long.class, - Long.class - ); + new CommandParameterInfo("value", Long.class, Long.class); writeUnitTestingNullableInt64sCommandParams.put( - "value", - unitTestingnullableInt64sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableInt64sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableInt64sAttribute", writeUnitTestingNullableInt64sAttributeInteractionInfo); - Map writeUnitTestingNullableEnum8CommandParams = new LinkedHashMap(); + "value", unitTestingnullableInt64sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableInt64sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableInt64sAttribute", writeUnitTestingNullableInt64sAttributeInteractionInfo); + Map writeUnitTestingNullableEnum8CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableEnum8CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableEnum8CommandParams.put( - "value", - unitTestingnullableEnum8CommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableEnum8CommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableEnum8Attribute", writeUnitTestingNullableEnum8AttributeInteractionInfo); - Map writeUnitTestingNullableEnum16CommandParams = new LinkedHashMap(); + "value", unitTestingnullableEnum8CommandParameterInfo); + InteractionInfo writeUnitTestingNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableEnum8CommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableEnum8Attribute", writeUnitTestingNullableEnum8AttributeInteractionInfo); + Map writeUnitTestingNullableEnum16CommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableEnum16CommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableEnum16CommandParams.put( - "value", - unitTestingnullableEnum16CommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableEnum16CommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableEnum16Attribute", writeUnitTestingNullableEnum16AttributeInteractionInfo); - Map writeUnitTestingNullableFloatSingleCommandParams = new LinkedHashMap(); + "value", unitTestingnullableEnum16CommandParameterInfo); + InteractionInfo writeUnitTestingNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableEnum16CommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableEnum16Attribute", writeUnitTestingNullableEnum16AttributeInteractionInfo); + Map writeUnitTestingNullableFloatSingleCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableFloatSingleCommandParameterInfo = - new CommandParameterInfo( - "value", - Float.class, - Float.class - ); + new CommandParameterInfo("value", Float.class, Float.class); writeUnitTestingNullableFloatSingleCommandParams.put( - "value", - unitTestingnullableFloatSingleCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableFloatSingleCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableFloatSingleAttribute", writeUnitTestingNullableFloatSingleAttributeInteractionInfo); - Map writeUnitTestingNullableFloatDoubleCommandParams = new LinkedHashMap(); + "value", unitTestingnullableFloatSingleCommandParameterInfo); + InteractionInfo writeUnitTestingNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableFloatSingleCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableFloatSingleAttribute", + writeUnitTestingNullableFloatSingleAttributeInteractionInfo); + Map writeUnitTestingNullableFloatDoubleCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableFloatDoubleCommandParameterInfo = - new CommandParameterInfo( - "value", - Double.class, - Double.class - ); + new CommandParameterInfo("value", Double.class, Double.class); writeUnitTestingNullableFloatDoubleCommandParams.put( - "value", - unitTestingnullableFloatDoubleCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableFloatDoubleCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableFloatDoubleAttribute", writeUnitTestingNullableFloatDoubleAttributeInteractionInfo); - Map writeUnitTestingNullableOctetStringCommandParams = new LinkedHashMap(); + "value", unitTestingnullableFloatDoubleCommandParameterInfo); + InteractionInfo writeUnitTestingNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableFloatDoubleCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableFloatDoubleAttribute", + writeUnitTestingNullableFloatDoubleAttributeInteractionInfo); + Map writeUnitTestingNullableOctetStringCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableOctetStringCommandParameterInfo = - new CommandParameterInfo( - "value", - byte[].class, - byte[].class - ); + new CommandParameterInfo("value", byte[].class, byte[].class); writeUnitTestingNullableOctetStringCommandParams.put( - "value", - unitTestingnullableOctetStringCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableOctetStringCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableOctetStringAttribute", writeUnitTestingNullableOctetStringAttributeInteractionInfo); - Map writeUnitTestingNullableCharStringCommandParams = new LinkedHashMap(); + "value", unitTestingnullableOctetStringCommandParameterInfo); + InteractionInfo writeUnitTestingNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableOctetStringCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableOctetStringAttribute", + writeUnitTestingNullableOctetStringAttributeInteractionInfo); + Map writeUnitTestingNullableCharStringCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableCharStringCommandParameterInfo = - new CommandParameterInfo( - "value", - String.class, - String.class - ); + new CommandParameterInfo("value", String.class, String.class); writeUnitTestingNullableCharStringCommandParams.put( - "value", - unitTestingnullableCharStringCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, - (String) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableCharStringCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableCharStringAttribute", writeUnitTestingNullableCharStringAttributeInteractionInfo); - Map writeUnitTestingNullableEnumAttrCommandParams = new LinkedHashMap(); + "value", unitTestingnullableCharStringCommandParameterInfo); + InteractionInfo writeUnitTestingNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableCharStringCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableCharStringAttribute", + writeUnitTestingNullableCharStringAttributeInteractionInfo); + Map writeUnitTestingNullableEnumAttrCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableEnumAttrCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableEnumAttrCommandParams.put( - "value", - unitTestingnullableEnumAttrCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableEnumAttrCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableEnumAttrAttribute", writeUnitTestingNullableEnumAttrAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableEnumAttrCommandParameterInfo); + InteractionInfo writeUnitTestingNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableEnumAttrCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableEnumAttrAttribute", writeUnitTestingNullableEnumAttrAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableRangeRestrictedInt8uCommandParams.put( - "value", - unitTestingnullableRangeRestrictedInt8uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt8uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt8uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableRangeRestrictedInt8uAttribute", + writeUnitTestingNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableRangeRestrictedInt8sCommandParams.put( - "value", - unitTestingnullableRangeRestrictedInt8sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt8sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt8sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableRangeRestrictedInt8sAttribute", + writeUnitTestingNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableRangeRestrictedInt16uCommandParams.put( - "value", - unitTestingnullableRangeRestrictedInt16uCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt16uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeUnitTestingNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + "value", unitTestingnullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt16uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableRangeRestrictedInt16uAttribute", + writeUnitTestingNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeUnitTestingNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingnullableRangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingNullableRangeRestrictedInt16sCommandParams.put( - "value", - unitTestingnullableRangeRestrictedInt16sCommandParameterInfo - ); - InteractionInfo writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingNullableRangeRestrictedInt16sCommandParams - ); - writeUnitTestingInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map writeUnitTestingWriteOnlyInt8uCommandParams = new LinkedHashMap(); + "value", unitTestingnullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingNullableRangeRestrictedInt16sCommandParams); + writeUnitTestingInteractionInfo.put( + "writeNullableRangeRestrictedInt16sAttribute", + writeUnitTestingNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map writeUnitTestingWriteOnlyInt8uCommandParams = + new LinkedHashMap(); CommandParameterInfo unitTestingwriteOnlyInt8uCommandParameterInfo = - new CommandParameterInfo( - "value", - Integer.class, - Integer.class - ); + new CommandParameterInfo("value", Integer.class, Integer.class); writeUnitTestingWriteOnlyInt8uCommandParams.put( - "value", - unitTestingwriteOnlyInt8uCommandParameterInfo - ); - InteractionInfo writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitTestingCluster) cluster).writeWriteOnlyInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("value") - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeUnitTestingWriteOnlyInt8uCommandParams - ); - writeUnitTestingInteractionInfo.put("writeWriteOnlyInt8uAttribute", writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo); + "value", unitTestingwriteOnlyInt8uCommandParameterInfo); + InteractionInfo writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitTestingCluster) cluster) + .writeWriteOnlyInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeUnitTestingWriteOnlyInt8uCommandParams); + writeUnitTestingInteractionInfo.put( + "writeWriteOnlyInt8uAttribute", writeUnitTestingWriteOnlyInt8uAttributeInteractionInfo); writeAttributeMap.put("unitTesting", writeUnitTestingInteractionInfo); Map writeFaultInjectionInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("faultInjection", writeFaultInjectionInteractionInfo);return writeAttributeMap; + writeAttributeMap.put("faultInjection", writeFaultInjectionInteractionInfo); + return writeAttributeMap; } } From 9b2f6986e1f920b0454d138ef5c5cff4039de220 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Wed, 24 May 2023 13:29:23 -0400 Subject: [PATCH 07/14] Add missing stuff to build.gn --- src/controller/data_model/BUILD.gn | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/controller/data_model/BUILD.gn b/src/controller/data_model/BUILD.gn index 1a89e51fb87a2b..06fc9cf2d5d08d 100644 --- a/src/controller/data_model/BUILD.gn +++ b/src/controller/data_model/BUILD.gn @@ -88,6 +88,8 @@ if (current_os == "android" || build_java_matter_controller) { "jni/DescriptorClient-ReadImpl.cpp", "jni/DiagnosticLogsClient-InvokeSubscribeImpl.cpp", "jni/DiagnosticLogsClient-ReadImpl.cpp", + "jni/DishwasherAlarmClient-InvokeSubscribeImpl.cpp", + "jni/DishwasherAlarmClient-ReadImpl.cpp", "jni/DoorLockClient-InvokeSubscribeImpl.cpp", "jni/DoorLockClient-ReadImpl.cpp", "jni/ElectricalMeasurementClient-InvokeSubscribeImpl.cpp", From bcce9491bb810c4e4cc9070051315da20e35f78c Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 15:09:33 +0000 Subject: [PATCH 08/14] Revert autoformat changes --- .github/workflows/tests.yaml | 1200 +++++++++-------- ...alarm.xml => dishwasher-alarm-cluster.xml} | 0 .../zcl/zcl-with-test-extensions.json | 62 +- 3 files changed, 615 insertions(+), 647 deletions(-) rename src/app/zap-templates/zcl/data-model/chip/{dishwasher-alarm.xml => dishwasher-alarm-cluster.xml} (100%) diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index 7b4f9ecf2a73ba..3af0aba8572ed9 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -15,608 +15,610 @@ name: Tests on: - push: - pull_request: - merge_group: - workflow_dispatch: + push: + pull_request: + merge_group: + workflow_dispatch: concurrency: - group: ${{ github.ref }}-${{ github.workflow }}-${{ (github.event_name == - 'pull_request' && github.event.number) || (github.event_name == - 'workflow_dispatch' && github.run_number) || github.sha }} - cancel-in-progress: true + group: ${{ github.ref }}-${{ github.workflow }}-${{ (github.event_name == + 'pull_request' && github.event.number) || (github.event_name == + 'workflow_dispatch' && github.run_number) || github.sha }} + cancel-in-progress: true env: - CHIP_NO_LOG_TIMESTAMPS: true - # XXX: Workaround for https://github.com/actions/cache/issues/1141 - SEGMENT_DOWNLOAD_TIMEOUT_MINS: 3 + CHIP_NO_LOG_TIMESTAMPS: true + # XXX: Workaround for https://github.com/actions/cache/issues/1141 + SEGMENT_DOWNLOAD_TIMEOUT_MINS: 3 jobs: - test_suites_linux: - name: Test Suites - Linux - timeout-minutes: 180 - - strategy: - matrix: - build_variant: [no-ble-tsan-clang] - chip_tool: [""] - env: - BUILD_VARIANT: ${{matrix.build_variant}} - CHIP_TOOL_VARIANT: ${{matrix.chip_tool}} - TSAN_OPTIONS: "halt_on_error=1 suppressions=scripts/tests/chiptest/tsan-linux-suppressions.txt" - LSAN_OPTIONS: detect_leaks=1 - - if: github.actor != 'restyled-io[bot]' - runs-on: ubuntu-latest - - container: - image: connectedhomeip/chip-build:0.7.3 - options: --privileged --sysctl "net.ipv6.conf.all.disable_ipv6=0 - net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" - - steps: - - uses: Wandalen/wretry.action@v1.0.36 - if: ${{ !env.ACT }} - name: Checkout - with: - action: actions/checkout@v3.5.2 - with: | - token: ${{ github.token }} - attempt_limit: 3 - attempt_delay: 2000 - # To use act like: - # act -j test_suites_linux - # - # Note you likely still need to have non submodules setup for the - # local machine, like: - # git submodule deinit --all - - uses: actions/checkout@v3.5.2 - if: ${{ env.ACT }} - name: Checkout (ACT for local build) - - name: Checkout submodules - run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform linux - - name: Try to ensure the directories for core dumping exist and we - can write them. - run: | - mkdir /tmp/cores || true - sysctl -w kernel.core_pattern=/tmp/cores/core.%u.%p.%t || true - mkdir objdir-clone || true - - - name: Bootstrap cache - uses: actions/cache@v3 - timeout-minutes: 10 - with: - key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} - path: | - .environment - build_overrides/pigweed_environment.gni - - name: Bootstrap - timeout-minutes: 10 - run: bash scripts/bootstrap.sh - - name: Uploading bootstrap logs - uses: actions/upload-artifact@v3 - if: ${{ always() && !env.ACT }} - with: - name: bootstrap-logs-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: | - .environment/gn_out/.ninja_log - .environment/pigweed-venv/*.log - - - name: Validate that xml are parsable - timeout-minutes: 10 - # The sub-items being run here are the same as the input XMLs listed - # at src/app/zap-templates/zcl/zcl.json - # - # This ensures that the syntax of the XML can always be parsed/validated, however it - # does not enforce that the content is understood (that part is covered by parser - # unit tests) - # - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/py_matter_idl/matter_idl/xml_parser.py \ - --no-print \ - --log-level info \ - src/app/zap-templates/zcl/data-model/chip/global-attributes.xml \ - src/app/zap-templates/zcl/data-model/chip/access-control-definitions.xml \ - src/app/zap-templates/zcl/data-model/chip/access-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/account-login-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/administrator-commissioning-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/air-quality-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/application-basic-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/application-launcher-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/audio-output-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/ballast-configuration-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/basic-information-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/binding-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/boolean-state-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/actions-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/bridged-device-basic-information.xml \ - src/app/zap-templates/zcl/data-model/chip/chip-ota.xml \ - src/app/zap-templates/zcl/data-model/chip/chip-types.xml \ - src/app/zap-templates/zcl/data-model/chip/channel-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/clusters-extensions.xml \ - src/app/zap-templates/zcl/data-model/chip/color-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/concentration-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/content-launch-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/descriptor-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/diagnostic-logs-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml \ - src/app/zap-templates/zcl/data-model/chip/dishwasher-mode-select-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/door-lock-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/ethernet-network-diagnostics-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/fan-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/fault-injection-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/fixed-label-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/flow-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/general-commissioning-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/general-diagnostics-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/global-attributes.xml \ - src/app/zap-templates/zcl/data-model/chip/groups-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/group-key-mgmt-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/identify-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/illuminance-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/keypad-input-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/laundry-washer-mode-select-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/level-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/localization-configuration-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/low-power-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/media-input-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/media-playback-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/mode-select-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/network-commissioning-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/occupancy-sensing-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/onoff-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/operational-credentials-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/operational-state-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/pressure-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/power-source-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/power-source-configuration-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/proxy-configuration-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/proxy-discovery-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/proxy-valid-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/pump-configuration-and-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/pwm-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/refrigerator-and-temperature-controlled-cabinet-mode-select-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml \ - src/app/zap-templates/zcl/data-model/chip/relative-humidity-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/rvc-clean-mode-select-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/rvc-run-mode-select-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/scene.xml \ - src/app/zap-templates/zcl/data-model/chip/software-diagnostics-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/switch-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/target-navigator-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/temperature-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/test-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/thermostat-user-interface-configuration-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/thread-network-diagnostics-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/time-format-localization-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/user-label-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/unit-localization-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/wake-on-lan-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/washer-controls-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/wifi-network-diagnostics-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/window-covering.xml \ - src/app/zap-templates/zcl/data-model/chip/temperature-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/matter-devices.xml \ - src/app/zap-templates/zcl/data-model/draft/barrier-control-cluster.xml \ - src/app/zap-templates/zcl/data-model/draft/electrical-measurement-cluster.xml \ - src/app/zap-templates/zcl/data-model/draft/input-output-value-clusters.xml \ - src/app/zap-templates/zcl/data-model/draft/onoff-switch-configuration-cluster.xml \ - src/app/zap-templates/zcl/data-model/chip/resource-monitoring-cluster.xml \ - " - - name: Build Apps - timeout-minutes: 60 - run: | - scripts/run_in_build_env.sh './scripts/build_python.sh --install_wheel build-env --include_yamltests' - ./scripts/run_in_build_env.sh \ - "./scripts/build/build_examples.py \ - --target linux-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT} \ - --target linux-x64-all-clusters-${BUILD_VARIANT} \ - --target linux-x64-lock-${BUILD_VARIANT} \ - --target linux-x64-ota-provider-${BUILD_VARIANT} \ - --target linux-x64-ota-requestor-${BUILD_VARIANT} \ - --target linux-x64-tv-app-${BUILD_VARIANT} \ - --target linux-x64-bridge-${BUILD_VARIANT} \ - build \ - --copy-artifacts-to objdir-clone \ - " - - name: Run Tests - timeout-minutes: 65 - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/tests/run_test_suite.py \ - --chip-tool ./out/linux-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ - run \ - --iterations 1 \ - --test-timeout-seconds 120 \ - --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ - --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ - --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ - --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ - --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ - --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ - " - - - name: Run Tests using the python parser sending commands to chip-tool - timeout-minutes: 65 - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/tests/run_test_suite.py \ - --runner chip_tool_python \ - --chip-tool ./out/linux-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ - run \ - --iterations 1 \ - --test-timeout-seconds 120 \ - --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ - --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ - --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ - --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ - --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ - --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ - " - - - name: Run Tests using chip-repl (skip slow) - timeout-minutes: 45 - if: github.event_name == 'pull_request' - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/tests/run_test_suite.py \ - --runner chip_repl_python \ - --exclude-tags MANUAL \ - --exclude-tags FLAKY \ - --exclude-tags IN_DEVELOPMENT \ - --exclude-tags SLOW \ - run \ - --iterations 1 \ - --test-timeout-seconds 120 \ - --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ - --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ - --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ - --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ - --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ - --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ - " - - name: Run Tests using chip-repl (including slow) - timeout-minutes: 45 - if: github.event_name == 'push' - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/tests/run_test_suite.py \ - --runner chip_repl_python \ - run \ - --iterations 1 \ - --test-timeout-seconds 120 \ - --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ - --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ - --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ - --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ - --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ - --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ - " - - name: Uploading core files - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-core-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: /tmp/cores/ - # Cores are big; don't hold on to them too long. - retention-days: 5 - - name: Uploading objdir for debugging - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-objdir-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: objdir-clone/ - # objdirs are big; don't hold on to them too long. - retention-days: 5 - - test_suites_darwin: - name: Test Suites - Darwin - timeout-minutes: 180 - - strategy: - matrix: - build_variant: [no-ble-tsan-clang, no-ble-asan-clang] - chip_tool: [""] - env: - BUILD_VARIANT: ${{matrix.build_variant}} - CHIP_TOOL_VARIANT: ${{matrix.chip_tool}} - TSAN_OPTIONS: "halt_on_error=1" - LSAN_OPTIONS: detect_leaks=1 suppressions=scripts/tests/chiptest/lsan-mac-suppressions.txt - - if: github.actor != 'restyled-io[bot]' - runs-on: macos-latest - - steps: - - uses: Wandalen/wretry.action@v1.0.36 - name: Checkout - with: - action: actions/checkout@v3.5.2 - with: | - token: ${{ github.token }} - attempt_limit: 3 - attempt_delay: 2000 - - name: Checkout submodules - run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform darwin - - name: Setup Environment - # coreutils for stdbuf - run: brew install coreutils - - name: Try to ensure the directories for core dumping and diagnostic - log collection exist and we can write them. - run: | - sudo chown ${USER} /cores || true - mkdir -p ~/Library/Logs/DiagnosticReports || true - mkdir objdir-clone || true - - - name: Bootstrap cache - uses: actions/cache@v3 - timeout-minutes: 10 - with: - key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} - path: | - .environment - build_overrides/pigweed_environment.gni - - name: Bootstrap - timeout-minutes: 25 - run: bash scripts/bootstrap.sh - - name: Uploading bootstrap logs - uses: actions/upload-artifact@v3 - if: ${{ always() && !env.ACT }} - with: - name: bootstrap-logs-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: | - .environment/gn_out/.ninja_log - .environment/pigweed-venv/*.log - - - name: Build Apps - timeout-minutes: 90 - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/build/build_examples.py \ - --target darwin-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT} \ - --target darwin-x64-all-clusters-${BUILD_VARIANT} \ - --target darwin-x64-lock-${BUILD_VARIANT} \ - --target darwin-x64-ota-provider-${BUILD_VARIANT} \ - --target darwin-x64-ota-requestor-${BUILD_VARIANT} \ - --target darwin-x64-tv-app-${BUILD_VARIANT} \ - --target darwin-x64-bridge-${BUILD_VARIANT} \ - build \ - --copy-artifacts-to objdir-clone \ - " - - name: Run Tests - timeout-minutes: 80 - if: matrix.build_variant != 'no-ble-tsan-clang' - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/tests/run_test_suite.py \ - --chip-tool ./out/darwin-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ - --target-skip-glob '{Test_TC_DGTHREAD_2_1,Test_TC_DGTHREAD_2_2,Test_TC_DGTHREAD_2_3,Test_TC_DGTHREAD_2_4}' \ - run \ - --iterations 1 \ - --test-timeout-seconds 120 \ - --all-clusters-app ./out/darwin-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ - --lock-app ./out/darwin-x64-lock-${BUILD_VARIANT}/chip-lock-app \ - --ota-provider-app ./out/darwin-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ - --ota-requestor-app ./out/darwin-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ - --tv-app ./out/darwin-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ - --bridge-app ./out/darwin-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ - " - - - name: Run Tests using the python parser sending commands to chip-tool - timeout-minutes: 80 - run: | - ./scripts/run_in_build_env.sh \ - "./scripts/tests/run_test_suite.py \ - --runner chip_tool_python \ - --chip-tool ./out/darwin-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ - --target-skip-glob '{Test_TC_DGTHREAD_2_1,Test_TC_DGTHREAD_2_2,Test_TC_DGTHREAD_2_3,Test_TC_DGTHREAD_2_4}' \ - run \ - --iterations 1 \ - --test-timeout-seconds 120 \ - --all-clusters-app ./out/darwin-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ - --lock-app ./out/darwin-x64-lock-${BUILD_VARIANT}/chip-lock-app \ - --ota-provider-app ./out/darwin-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ - --ota-requestor-app ./out/darwin-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ - --tv-app ./out/darwin-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ - --bridge-app ./out/darwin-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ - " - - - name: Uploading core files - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-core-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: /cores/ - # Cores are big; don't hold on to them too long. - retention-days: 5 - - name: Uploading diagnostic logs - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-log-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: ~/Library/Logs/DiagnosticReports/ - - name: Uploading objdir for debugging - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-objdir-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: objdir-clone/ - # objdirs are big; don't hold on to them too long. - retention-days: 5 - - repl_tests_linux: - name: REPL Tests - Linux - timeout-minutes: 130 - - env: - TSAN_OPTIONS: "halt_on_error=1 suppressions=scripts/tests/chiptest/tsan-linux-suppressions.txt" - - if: github.actor != 'restyled-io[bot]' - runs-on: ubuntu-latest - - container: - image: connectedhomeip/chip-build:0.7.3 - options: --privileged --sysctl "net.ipv6.conf.all.disable_ipv6=0 - net.ipv4.conf.all.forwarding=0 net.ipv6.conf.all.forwarding=0" - - steps: - - name: Checkout - uses: actions/checkout@v3.5.2 - - name: Checkout submodules - run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform linux - - name: Try to ensure the directories for core dumping exist and we - can write them. - run: | - mkdir /tmp/cores || true - sysctl -w kernel.core_pattern=/tmp/cores/core.%u.%p.%t || true - mkdir objdir-clone || true - - - name: Bootstrap cache - uses: actions/cache@v3 - timeout-minutes: 10 - with: - key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} - path: | - .environment - build_overrides/pigweed_environment.gni - - name: Bootstrap - timeout-minutes: 10 - run: bash scripts/bootstrap.sh - - name: Uploading bootstrap logs - uses: actions/upload-artifact@v3 - if: ${{ always() && !env.ACT }} - with: - name: bootstrap-logs-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: | - .environment/gn_out/.ninja_log - .environment/pigweed-venv/*.log - - - name: Build Python REPL and example apps - timeout-minutes: 50 - run: | - scripts/run_in_build_env.sh './scripts/build_python.sh --install_wheel build-env --extra_packages "mobly"' - ./scripts/run_in_build_env.sh \ - "./scripts/build/build_examples.py \ - --target linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test \ - --target linux-x64-python-bindings \ - build \ - --copy-artifacts-to objdir-clone \ - " - - name: Run Tests - timeout-minutes: 10 - run: | - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --script-args "--log-level INFO -t 3600 --disable-test ClusterObjectTests.TestTimedRequestTimeout"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_RR_1_1.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_SC_3_6.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_DA_1_7.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --bool-arg allow_sdk_dac:true"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1 --enable-key 000102030405060708090a0b0c0d0e0f" --script "src/python_testing/TC_TestEventTrigger.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --bool-arg allow_sdk_dac:true"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_ACE_1_4.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --int-arg PIXIT.ACE.APPENDPOINT:1 PIXIT.ACE.APPDEVTYPEID:0x0100 --string-arg PIXIT.ACE.APPCLUSTER:OnOff PIXIT.ACE.APPATTRIBUTE:OnOff"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_ACE_1_3.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_CGEN_2_4.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_DA_1_2.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --PICS src/app/tests/suites/certification/ci-pics-values"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_DA_1_5.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --PICS src/app/tests/suites/certification/ci-pics-values"' - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --script "src/python_testing/TestMatterTestingSupport.py"' - - name: Uploading core files - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-core-linux-python-repl - path: /tmp/cores/ - # Cores are big; don't hold on to them too long. - retention-days: 5 - - name: Uploading objdir for debugging - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-objdir-linux-python-repl - path: objdir-clone/ - # objdirs are big; don't hold on to them too long. - retention-days: 5 - - repl_tests_darwin: - name: REPL Tests - Darwin - timeout-minutes: 120 - - strategy: - matrix: - build_variant: [no-ble-no-wifi-tsan-clang] - env: - BUILD_VARIANT: ${{matrix.build_variant}} - TSAN_OPTIONS: "halt_on_error=1" - - if: github.actor != 'restyled-io[bot]' && false - runs-on: macos-latest - - steps: - - name: Checkout - uses: actions/checkout@v3.5.2 - - name: Checkout submodules - run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform darwin - - name: Setup Environment - # coreutils for stdbuf - run: brew install coreutils - - name: Try to ensure the directories for core dumping and diagnostic - log collection exist and we can write them. - run: | - sudo chown ${USER} /cores || true - mkdir -p ~/Library/Logs/DiagnosticReports || true - mkdir objdir-clone || true - - - name: Bootstrap cache - uses: actions/cache@v3 - timeout-minutes: 10 - with: - key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} - path: | - .environment - build_overrides/pigweed_environment.gni - - name: Bootstrap - timeout-minutes: 25 - run: bash scripts/bootstrap.sh - - name: Uploading bootstrap logs - uses: actions/upload-artifact@v3 - if: ${{ always() && !env.ACT }} - with: - name: bootstrap-logs-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} - path: | - .environment/gn_out/.ninja_log - .environment/pigweed-venv/*.log - - - name: Build Python REPL and example apps - timeout-minutes: 50 - run: | - scripts/run_in_build_env.sh './scripts/build_python.sh --install_wheel build-env' - ./scripts/run_in_build_env.sh \ - "./scripts/build/build_examples.py \ - --target darwin-x64-all-clusters-${BUILD_VARIANT}-test \ - build \ - --copy-artifacts-to objdir-clone \ - " - - name: Run Tests - timeout-minutes: 30 - run: | - scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/darwin-x64-all-clusters-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 3840 --interface-id -1" --script-args "-t 3600 --disable-test ClusterObjectTests.TestTimedRequestTimeout"' - - name: Uploading core files - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-core-darwin-python-repl - path: /cores/ - # Cores are big; don't hold on to them too long. - retention-days: 5 - - name: Uploading diagnostic logs - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-log-darwin-python-repl - path: ~/Library/Logs/DiagnosticReports/ - - name: Uploading objdir for debugging - uses: actions/upload-artifact@v3 - if: ${{ failure() && !env.ACT }} - with: - name: crash-objdir-darwin-python-repl - path: objdir-clone/ - # objdirs are big; don't hold on to them too long. - retention-days: 5 + test_suites_linux: + name: Test Suites - Linux + timeout-minutes: 180 + + strategy: + matrix: + build_variant: [no-ble-tsan-clang] + chip_tool: [""] + env: + BUILD_VARIANT: ${{matrix.build_variant}} + CHIP_TOOL_VARIANT: ${{matrix.chip_tool}} + TSAN_OPTIONS: "halt_on_error=1 suppressions=scripts/tests/chiptest/tsan-linux-suppressions.txt" + LSAN_OPTIONS: detect_leaks=1 + + if: github.actor != 'restyled-io[bot]' + runs-on: ubuntu-latest + + container: + image: connectedhomeip/chip-build:0.7.3 + options: --privileged --sysctl "net.ipv6.conf.all.disable_ipv6=0 + net.ipv4.conf.all.forwarding=1 net.ipv6.conf.all.forwarding=1" + + steps: + - uses: Wandalen/wretry.action@v1.0.36 + if: ${{ !env.ACT }} + name: Checkout + with: + action: actions/checkout@v3.5.2 + with: | + token: ${{ github.token }} + attempt_limit: 3 + attempt_delay: 2000 + # To use act like: + # act -j test_suites_linux + # + # Note you likely still need to have non submodules setup for the + # local machine, like: + # git submodule deinit --all + - uses: actions/checkout@v3.5.2 + if: ${{ env.ACT }} + name: Checkout (ACT for local build) + - name: Checkout submodules + run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform linux + - name: Try to ensure the directories for core dumping exist and we + can write them. + run: | + mkdir /tmp/cores || true + sysctl -w kernel.core_pattern=/tmp/cores/core.%u.%p.%t || true + mkdir objdir-clone || true + + - name: Bootstrap cache + uses: actions/cache@v3 + timeout-minutes: 10 + with: + key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} + path: | + .environment + build_overrides/pigweed_environment.gni + - name: Bootstrap + timeout-minutes: 10 + run: bash scripts/bootstrap.sh + - name: Uploading bootstrap logs + uses: actions/upload-artifact@v3 + if: ${{ always() && !env.ACT }} + with: + name: bootstrap-logs-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: | + .environment/gn_out/.ninja_log + .environment/pigweed-venv/*.log + + - name: Validate that xml are parsable + timeout-minutes: 10 + # The sub-items being run here are the same as the input XMLs listed + # at src/app/zap-templates/zcl/zcl.json + # + # This ensures that the syntax of the XML can always be parsed/validated, however it + # does not enforce that the content is understood (that part is covered by parser + # unit tests) + # + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/py_matter_idl/matter_idl/xml_parser.py \ + --no-print \ + --log-level info \ + src/app/zap-templates/zcl/data-model/chip/global-attributes.xml \ + src/app/zap-templates/zcl/data-model/chip/access-control-definitions.xml \ + src/app/zap-templates/zcl/data-model/chip/access-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/account-login-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/administrator-commissioning-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/air-quality-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/application-basic-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/application-launcher-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/audio-output-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/ballast-configuration-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/basic-information-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/binding-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/boolean-state-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/actions-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/bridged-device-basic-information.xml \ + src/app/zap-templates/zcl/data-model/chip/chip-ota.xml \ + src/app/zap-templates/zcl/data-model/chip/chip-types.xml \ + src/app/zap-templates/zcl/data-model/chip/channel-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/clusters-extensions.xml \ + src/app/zap-templates/zcl/data-model/chip/color-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/concentration-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/content-launch-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/descriptor-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/diagnostic-logs-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/dishwasher-mode-select-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/door-lock-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/ethernet-network-diagnostics-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/fan-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/fault-injection-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/fixed-label-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/flow-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/general-commissioning-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/general-diagnostics-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/global-attributes.xml \ + src/app/zap-templates/zcl/data-model/chip/groups-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/group-key-mgmt-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/identify-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/illuminance-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/keypad-input-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/laundry-washer-mode-select-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/level-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/localization-configuration-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/low-power-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/media-input-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/media-playback-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/mode-select-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/network-commissioning-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/occupancy-sensing-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/onoff-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/operational-credentials-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/operational-state-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/pressure-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/power-source-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/power-source-configuration-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/proxy-configuration-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/proxy-discovery-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/proxy-valid-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/pump-configuration-and-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/pwm-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/refrigerator-and-temperature-controlled-cabinet-mode-select-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/refrigerator-alarm.xml \ + src/app/zap-templates/zcl/data-model/chip/relative-humidity-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/rvc-clean-mode-select-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/rvc-run-mode-select-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/scene.xml \ + src/app/zap-templates/zcl/data-model/chip/software-diagnostics-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/switch-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/target-navigator-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/temperature-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/test-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/thermostat-user-interface-configuration-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/thermostat-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/thread-network-diagnostics-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/time-format-localization-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/time-synchronization-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/user-label-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/unit-localization-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/wake-on-lan-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/washer-controls-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/wifi-network-diagnostics-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/window-covering.xml \ + src/app/zap-templates/zcl/data-model/chip/temperature-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/matter-devices.xml \ + src/app/zap-templates/zcl/data-model/draft/barrier-control-cluster.xml \ + src/app/zap-templates/zcl/data-model/draft/electrical-measurement-cluster.xml \ + src/app/zap-templates/zcl/data-model/draft/input-output-value-clusters.xml \ + src/app/zap-templates/zcl/data-model/draft/onoff-switch-configuration-cluster.xml \ + src/app/zap-templates/zcl/data-model/chip/resource-monitoring-cluster.xml \ + " + - name: Build Apps + timeout-minutes: 60 + run: | + scripts/run_in_build_env.sh './scripts/build_python.sh --install_wheel build-env --include_yamltests' + ./scripts/run_in_build_env.sh \ + "./scripts/build/build_examples.py \ + --target linux-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT} \ + --target linux-x64-all-clusters-${BUILD_VARIANT} \ + --target linux-x64-lock-${BUILD_VARIANT} \ + --target linux-x64-ota-provider-${BUILD_VARIANT} \ + --target linux-x64-ota-requestor-${BUILD_VARIANT} \ + --target linux-x64-tv-app-${BUILD_VARIANT} \ + --target linux-x64-bridge-${BUILD_VARIANT} \ + build \ + --copy-artifacts-to objdir-clone \ + " + - name: Run Tests + timeout-minutes: 65 + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/tests/run_test_suite.py \ + --chip-tool ./out/linux-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ + run \ + --iterations 1 \ + --test-timeout-seconds 120 \ + --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ + --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ + --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ + --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ + --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ + --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ + " + + - name: Run Tests using the python parser sending commands to chip-tool + timeout-minutes: 65 + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/tests/run_test_suite.py \ + --runner chip_tool_python \ + --chip-tool ./out/linux-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ + run \ + --iterations 1 \ + --test-timeout-seconds 120 \ + --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ + --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ + --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ + --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ + --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ + --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ + " + + - name: Run Tests using chip-repl (skip slow) + timeout-minutes: 45 + if: github.event_name == 'pull_request' + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/tests/run_test_suite.py \ + --runner chip_repl_python \ + --exclude-tags MANUAL \ + --exclude-tags FLAKY \ + --exclude-tags IN_DEVELOPMENT \ + --exclude-tags SLOW \ + run \ + --iterations 1 \ + --test-timeout-seconds 120 \ + --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ + --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ + --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ + --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ + --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ + --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ + " + - name: Run Tests using chip-repl (including slow) + timeout-minutes: 45 + if: github.event_name == 'push' + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/tests/run_test_suite.py \ + --runner chip_repl_python \ + run \ + --iterations 1 \ + --test-timeout-seconds 120 \ + --all-clusters-app ./out/linux-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ + --lock-app ./out/linux-x64-lock-${BUILD_VARIANT}/chip-lock-app \ + --ota-provider-app ./out/linux-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ + --ota-requestor-app ./out/linux-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ + --tv-app ./out/linux-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ + --bridge-app ./out/linux-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ + " + - name: Uploading core files + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-core-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: /tmp/cores/ + # Cores are big; don't hold on to them too long. + retention-days: 5 + - name: Uploading objdir for debugging + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-objdir-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: objdir-clone/ + # objdirs are big; don't hold on to them too long. + retention-days: 5 + + test_suites_darwin: + name: Test Suites - Darwin + timeout-minutes: 180 + + strategy: + matrix: + build_variant: [no-ble-tsan-clang, no-ble-asan-clang] + chip_tool: [""] + env: + BUILD_VARIANT: ${{matrix.build_variant}} + CHIP_TOOL_VARIANT: ${{matrix.chip_tool}} + TSAN_OPTIONS: "halt_on_error=1" + LSAN_OPTIONS: detect_leaks=1 suppressions=scripts/tests/chiptest/lsan-mac-suppressions.txt + + if: github.actor != 'restyled-io[bot]' + runs-on: macos-latest + + steps: + - uses: Wandalen/wretry.action@v1.0.36 + name: Checkout + with: + action: actions/checkout@v3.5.2 + with: | + token: ${{ github.token }} + attempt_limit: 3 + attempt_delay: 2000 + - name: Checkout submodules + run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform darwin + - name: Setup Environment + # coreutils for stdbuf + run: brew install coreutils + - name: + Try to ensure the directories for core dumping and diagnostic + log collection exist and we can write them. + run: | + sudo chown ${USER} /cores || true + mkdir -p ~/Library/Logs/DiagnosticReports || true + mkdir objdir-clone || true + + - name: Bootstrap cache + uses: actions/cache@v3 + timeout-minutes: 10 + with: + key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} + path: | + .environment + build_overrides/pigweed_environment.gni + - name: Bootstrap + timeout-minutes: 25 + run: bash scripts/bootstrap.sh + - name: Uploading bootstrap logs + uses: actions/upload-artifact@v3 + if: ${{ always() && !env.ACT }} + with: + name: bootstrap-logs-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: | + .environment/gn_out/.ninja_log + .environment/pigweed-venv/*.log + + - name: Build Apps + timeout-minutes: 90 + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/build/build_examples.py \ + --target darwin-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT} \ + --target darwin-x64-all-clusters-${BUILD_VARIANT} \ + --target darwin-x64-lock-${BUILD_VARIANT} \ + --target darwin-x64-ota-provider-${BUILD_VARIANT} \ + --target darwin-x64-ota-requestor-${BUILD_VARIANT} \ + --target darwin-x64-tv-app-${BUILD_VARIANT} \ + --target darwin-x64-bridge-${BUILD_VARIANT} \ + build \ + --copy-artifacts-to objdir-clone \ + " + - name: Run Tests + timeout-minutes: 80 + if: matrix.build_variant != 'no-ble-tsan-clang' + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/tests/run_test_suite.py \ + --chip-tool ./out/darwin-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ + --target-skip-glob '{Test_TC_DGTHREAD_2_1,Test_TC_DGTHREAD_2_2,Test_TC_DGTHREAD_2_3,Test_TC_DGTHREAD_2_4}' \ + run \ + --iterations 1 \ + --test-timeout-seconds 120 \ + --all-clusters-app ./out/darwin-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ + --lock-app ./out/darwin-x64-lock-${BUILD_VARIANT}/chip-lock-app \ + --ota-provider-app ./out/darwin-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ + --ota-requestor-app ./out/darwin-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ + --tv-app ./out/darwin-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ + --bridge-app ./out/darwin-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ + " + + - name: Run Tests using the python parser sending commands to chip-tool + timeout-minutes: 80 + run: | + ./scripts/run_in_build_env.sh \ + "./scripts/tests/run_test_suite.py \ + --runner chip_tool_python \ + --chip-tool ./out/darwin-x64-chip-tool${CHIP_TOOL_VARIANT}-${BUILD_VARIANT}/chip-tool \ + --target-skip-glob '{Test_TC_DGTHREAD_2_1,Test_TC_DGTHREAD_2_2,Test_TC_DGTHREAD_2_3,Test_TC_DGTHREAD_2_4}' \ + run \ + --iterations 1 \ + --test-timeout-seconds 120 \ + --all-clusters-app ./out/darwin-x64-all-clusters-${BUILD_VARIANT}/chip-all-clusters-app \ + --lock-app ./out/darwin-x64-lock-${BUILD_VARIANT}/chip-lock-app \ + --ota-provider-app ./out/darwin-x64-ota-provider-${BUILD_VARIANT}/chip-ota-provider-app \ + --ota-requestor-app ./out/darwin-x64-ota-requestor-${BUILD_VARIANT}/chip-ota-requestor-app \ + --tv-app ./out/darwin-x64-tv-app-${BUILD_VARIANT}/chip-tv-app \ + --bridge-app ./out/darwin-x64-bridge-${BUILD_VARIANT}/chip-bridge-app \ + " + + - name: Uploading core files + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-core-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: /cores/ + # Cores are big; don't hold on to them too long. + retention-days: 5 + - name: Uploading diagnostic logs + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-log-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: ~/Library/Logs/DiagnosticReports/ + - name: Uploading objdir for debugging + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-objdir-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: objdir-clone/ + # objdirs are big; don't hold on to them too long. + retention-days: 5 + + repl_tests_linux: + name: REPL Tests - Linux + timeout-minutes: 130 + + env: + TSAN_OPTIONS: "halt_on_error=1 suppressions=scripts/tests/chiptest/tsan-linux-suppressions.txt" + + if: github.actor != 'restyled-io[bot]' + runs-on: ubuntu-latest + + container: + image: connectedhomeip/chip-build:0.7.3 + options: --privileged --sysctl "net.ipv6.conf.all.disable_ipv6=0 + net.ipv4.conf.all.forwarding=0 net.ipv6.conf.all.forwarding=0" + + steps: + - name: Checkout + uses: actions/checkout@v3.5.2 + - name: Checkout submodules + run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform linux + - name: Try to ensure the directories for core dumping exist and we + can write them. + run: | + mkdir /tmp/cores || true + sysctl -w kernel.core_pattern=/tmp/cores/core.%u.%p.%t || true + mkdir objdir-clone || true + + - name: Bootstrap cache + uses: actions/cache@v3 + timeout-minutes: 10 + with: + key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} + path: | + .environment + build_overrides/pigweed_environment.gni + - name: Bootstrap + timeout-minutes: 10 + run: bash scripts/bootstrap.sh + - name: Uploading bootstrap logs + uses: actions/upload-artifact@v3 + if: ${{ always() && !env.ACT }} + with: + name: bootstrap-logs-linux-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: | + .environment/gn_out/.ninja_log + .environment/pigweed-venv/*.log + + - name: Build Python REPL and example apps + timeout-minutes: 50 + run: | + scripts/run_in_build_env.sh './scripts/build_python.sh --install_wheel build-env --extra_packages "mobly"' + ./scripts/run_in_build_env.sh \ + "./scripts/build/build_examples.py \ + --target linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test \ + --target linux-x64-python-bindings \ + build \ + --copy-artifacts-to objdir-clone \ + " + - name: Run Tests + timeout-minutes: 10 + run: | + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --script-args "--log-level INFO -t 3600 --disable-test ClusterObjectTests.TestTimedRequestTimeout"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_RR_1_1.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_SC_3_6.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_DA_1_7.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --bool-arg allow_sdk_dac:true"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1 --enable-key 000102030405060708090a0b0c0d0e0f" --script "src/python_testing/TC_TestEventTrigger.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --bool-arg allow_sdk_dac:true"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_ACE_1_4.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --int-arg PIXIT.ACE.APPENDPOINT:1 PIXIT.ACE.APPDEVTYPEID:0x0100 --string-arg PIXIT.ACE.APPCLUSTER:OnOff PIXIT.ACE.APPATTRIBUTE:OnOff"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_ACE_1_3.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_CGEN_2_4.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_DA_1_2.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --PICS src/app/tests/suites/certification/ci-pics-values"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/linux-x64-all-clusters-ipv6only-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 1234 --KVS kvs1 --trace_decode 1" --script "src/python_testing/TC_DA_1_5.py" --script-args "--storage-path admin_storage.json --commissioning-method on-network --discriminator 1234 --passcode 20202021 --PICS src/app/tests/suites/certification/ci-pics-values"' + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --script "src/python_testing/TestMatterTestingSupport.py"' + - name: Uploading core files + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-core-linux-python-repl + path: /tmp/cores/ + # Cores are big; don't hold on to them too long. + retention-days: 5 + - name: Uploading objdir for debugging + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-objdir-linux-python-repl + path: objdir-clone/ + # objdirs are big; don't hold on to them too long. + retention-days: 5 + + repl_tests_darwin: + name: REPL Tests - Darwin + timeout-minutes: 120 + + strategy: + matrix: + build_variant: [no-ble-no-wifi-tsan-clang] + env: + BUILD_VARIANT: ${{matrix.build_variant}} + TSAN_OPTIONS: "halt_on_error=1" + + if: github.actor != 'restyled-io[bot]' && false + runs-on: macos-latest + + steps: + - name: Checkout + uses: actions/checkout@v3.5.2 + - name: Checkout submodules + run: scripts/checkout_submodules.py --allow-changing-global-git-config --shallow --platform darwin + - name: Setup Environment + # coreutils for stdbuf + run: brew install coreutils + - name: + Try to ensure the directories for core dumping and diagnostic + log collection exist and we can write them. + run: | + sudo chown ${USER} /cores || true + mkdir -p ~/Library/Logs/DiagnosticReports || true + mkdir objdir-clone || true + + - name: Bootstrap cache + uses: actions/cache@v3 + timeout-minutes: 10 + with: + key: ${{ runner.os }}-env-${{ hashFiles('scripts/setup/*', 'third_party/pigweed/**') }} + path: | + .environment + build_overrides/pigweed_environment.gni + - name: Bootstrap + timeout-minutes: 25 + run: bash scripts/bootstrap.sh + - name: Uploading bootstrap logs + uses: actions/upload-artifact@v3 + if: ${{ always() && !env.ACT }} + with: + name: bootstrap-logs-darwin-${{ matrix.build_variant }}${{ matrix.chip_tool }} + path: | + .environment/gn_out/.ninja_log + .environment/pigweed-venv/*.log + + - name: Build Python REPL and example apps + timeout-minutes: 50 + run: | + scripts/run_in_build_env.sh './scripts/build_python.sh --install_wheel build-env' + ./scripts/run_in_build_env.sh \ + "./scripts/build/build_examples.py \ + --target darwin-x64-all-clusters-${BUILD_VARIANT}-test \ + build \ + --copy-artifacts-to objdir-clone \ + " + - name: Run Tests + timeout-minutes: 30 + run: | + scripts/run_in_build_env.sh './scripts/tests/run_python_test.py --app out/darwin-x64-all-clusters-no-ble-no-wifi-tsan-clang-test/chip-all-clusters-app --factoryreset --app-args "--discriminator 3840 --interface-id -1" --script-args "-t 3600 --disable-test ClusterObjectTests.TestTimedRequestTimeout"' + - name: Uploading core files + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-core-darwin-python-repl + path: /cores/ + # Cores are big; don't hold on to them too long. + retention-days: 5 + - name: Uploading diagnostic logs + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-log-darwin-python-repl + path: ~/Library/Logs/DiagnosticReports/ + - name: Uploading objdir for debugging + uses: actions/upload-artifact@v3 + if: ${{ failure() && !env.ACT }} + with: + name: crash-objdir-darwin-python-repl + path: objdir-clone/ + # objdirs are big; don't hold on to them too long. + retention-days: 5 diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml similarity index 100% rename from src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm.xml rename to src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json index 063ba68bf38538..0c295654150a3f 100644 --- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json +++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json @@ -35,7 +35,7 @@ "content-launch-cluster.xml", "descriptor-cluster.xml", "diagnostic-logs-cluster.xml", - "dishwasher-alarm.xml", + "dishwasher-alarm-cluster.xml", "dishwasher-mode-select-cluster.xml", "door-lock-cluster.xml", "electrical-measurement-cluster.xml", @@ -111,15 +111,9 @@ "manufacturersXml": "../../../../src/app/zap-templates/zcl/data-model/manufacturers.xml", "options": { "text": { - "defaultResponsePolicy": [ - "Always", - "Conditional", - "Never" - ] + "defaultResponsePolicy": ["Always", "Conditional", "Never"] }, - "bool": [ - "commandDiscovery" - ] + "bool": ["commandDiscovery"] }, "defaults": { "text": { @@ -163,12 +157,8 @@ "CapabilityMinima", "ProductAppearance" ], - "Bridged Device Basic Information": [ - "ProductAppearance" - ], - "Descriptor": [ - "ClusterRevision" - ], + "Bridged Device Basic Information": ["ProductAppearance"], + "Descriptor": ["ClusterRevision"], "Ethernet Network Diagnostics": [ "PHYRate", "FullDuplex", @@ -214,10 +204,7 @@ "FeatureMap", "ThreadMetrics" ], - "Scenes": [ - "SceneCount", - "RemainingCapacity" - ], + "Scenes": ["SceneCount", "RemainingCapacity"], "Unit Testing": [ "struct_attr", "nullable_struct", @@ -301,19 +288,10 @@ "CurrentMaxRate", "OverrunCount" ], - "Channel": [ - "Lineup", - "CurrentChannel" - ], - "Media Playback": [ - "SampledPosition" - ], - "Application Launcher": [ - "CurrentApp" - ], - "Application Basic": [ - "Application" - ], + "Channel": ["Lineup", "CurrentChannel"], + "Media Playback": ["SampledPosition"], + "Application Launcher": ["CurrentApp"], + "Application Basic": ["Application"], "Time Synchronization": [ "TrustedTimeSource", "DefaultNTP", @@ -322,27 +300,15 @@ "UTCTime", "LocalTime" ], - "Temperature Control": [ - "SupportedTemperatureLevels" - ], - "Operational State": [ - "OperationalState", - "OperationalError" - ] + "Temperature Control": ["SupportedTemperatureLevels"], + "Operational State": ["OperationalState", "OperationalError"] }, "defaultReportingPolicy": "mandatory", - "ZCLDataTypes": [ - "ARRAY", - "BITMAP", - "ENUM", - "NUMBER", - "STRING", - "STRUCT" - ], + "ZCLDataTypes": ["ARRAY", "BITMAP", "ENUM", "NUMBER", "STRING", "STRUCT"], "fabricHandling": { "automaticallyCreateFields": true, "indexFieldId": 254, "indexFieldName": "FabricIndex", "indexType": "fabric_idx" } -} \ No newline at end of file +} From 6d6f1743d3a08a91f8176e3725810df893b71bb0 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 15:15:00 +0000 Subject: [PATCH 09/14] Revert reformat changes --- src/app/zap-templates/zcl/zcl.json | 62 +++++++----------------------- 1 file changed, 14 insertions(+), 48 deletions(-) diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json index 27feca7063d0f5..968ba77aed0553 100644 --- a/src/app/zap-templates/zcl/zcl.json +++ b/src/app/zap-templates/zcl/zcl.json @@ -34,7 +34,7 @@ "content-launch-cluster.xml", "descriptor-cluster.xml", "diagnostic-logs-cluster.xml", - "dishwasher-alarm.xml", + "dishwasher-alarm-cluster.xml", "dishwasher-mode-select-cluster.xml", "door-lock-cluster.xml", "electrical-measurement-cluster.xml", @@ -109,15 +109,9 @@ "manufacturersXml": "../../../../src/app/zap-templates/zcl/data-model/manufacturers.xml", "options": { "text": { - "defaultResponsePolicy": [ - "Always", - "Conditional", - "Never" - ] + "defaultResponsePolicy": ["Always", "Conditional", "Never"] }, - "bool": [ - "commandDiscovery" - ] + "bool": ["commandDiscovery"] }, "defaults": { "text": { @@ -161,12 +155,8 @@ "CapabilityMinima", "ProductAppearance" ], - "Bridged Device Basic Information": [ - "ProductAppearance" - ], - "Descriptor": [ - "ClusterRevision" - ], + "Bridged Device Basic Information": ["ProductAppearance"], + "Descriptor": ["ClusterRevision"], "Ethernet Network Diagnostics": [ "PHYRate", "FullDuplex", @@ -212,10 +202,7 @@ "FeatureMap", "ThreadMetrics" ], - "Scenes": [ - "SceneCount", - "RemainingCapacity" - ], + "Scenes": ["SceneCount", "RemainingCapacity"], "Unit Testing": [ "struct_attr", "nullable_struct", @@ -299,19 +286,10 @@ "CurrentMaxRate", "OverrunCount" ], - "Channel": [ - "Lineup", - "CurrentChannel" - ], - "Media Playback": [ - "SampledPosition" - ], - "Application Launcher": [ - "CurrentApp" - ], - "Application Basic": [ - "Application" - ], + "Channel": ["Lineup", "CurrentChannel"], + "Media Playback": ["SampledPosition"], + "Application Launcher": ["CurrentApp"], + "Application Basic": ["Application"], "Time Synchronization": [ "TrustedTimeSource", "DefaultNTP", @@ -320,27 +298,15 @@ "UTCTime", "LocalTime" ], - "Temperature Control": [ - "SupportedTemperatureLevels" - ], - "Operational State": [ - "OperationalState", - "OperationalError" - ] + "Temperature Control": ["SupportedTemperatureLevels"], + "Operational State": ["OperationalState", "OperationalError"] }, "defaultReportingPolicy": "mandatory", - "ZCLDataTypes": [ - "ARRAY", - "BITMAP", - "ENUM", - "NUMBER", - "STRING", - "STRUCT" - ], + "ZCLDataTypes": ["ARRAY", "BITMAP", "ENUM", "NUMBER", "STRING", "STRUCT"], "fabricHandling": { "automaticallyCreateFields": true, "indexFieldId": 254, "indexFieldName": "FabricIndex", "indexType": "fabric_idx" } -} \ No newline at end of file +} From 2c057cbba5291e9742dbdba982fb441781f5de8e Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 15:21:29 +0000 Subject: [PATCH 10/14] Revert autoformat changes --- src/app/zap_cluster_list.json | 237 +++++++++------------------------- 1 file changed, 61 insertions(+), 176 deletions(-) diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json index 7285ea7c67a03e..dec99f33d50c45 100644 --- a/src/app/zap_cluster_list.json +++ b/src/app/zap_cluster_list.json @@ -36,7 +36,7 @@ "DESCRIPTOR_CLUSTER": [], "DEVICE_TEMP_CLUSTER": [], "DIAGNOSTIC_LOGS_CLUSTER": [], - "DISHWASHER_ALARM": [], + "DISHWASHER_ALARM_CLUSTER": [], "DISHWASHER_MODE_SELECT_CLUSTER": [], "DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER": [], "DOOR_LOCK_CLUSTER": [], @@ -80,9 +80,7 @@ "NETWORK_COMMISSIONING_CLUSTER": [], "NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "OCCUPANCY_SENSING_CLUSTER": [ - "occupancy-sensor-server" - ], + "OCCUPANCY_SENSING_CLUSTER": ["occupancy-sensor-server"], "ON_OFF_CLUSTER": [], "ON_OFF_SWITCH_CONFIGURATION_CLUSTER": [], "OPERATIONAL_CREDENTIALS_CLUSTER": [], @@ -125,9 +123,7 @@ "TARGET_NAVIGATOR_CLUSTER": [], "TEMPERATURE_CONTROL_CLUSTER": [], "TEMPERATURE_MEASUREMENT_CLUSTER": [], - "THERMOSTAT_CLUSTER": [ - "thermostat-client" - ], + "THERMOSTAT_CLUSTER": ["thermostat-client"], "THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER": [], "THREAD_NETWORK_DIAGNOSTICS_CLUSTER": [], "TIME_CLUSTER": [], @@ -152,12 +148,8 @@ "ZLL_COMMISSIONING_CLUSTER": [] }, "ServerDirectories": { - "ACCESS_CONTROL_CLUSTER": [ - "access-control-server" - ], - "ACCOUNT_LOGIN_CLUSTER": [ - "account-login-server" - ], + "ACCESS_CONTROL_CLUSTER": ["access-control-server"], + "ACCOUNT_LOGIN_CLUSTER": ["account-login-server"], "ACTIONS_CLUSTER": [], "ACTIVATED_CARBON_FILTER_MONITORING_CLUSTER": [], "ADMINISTRATOR_COMMISSIONING_CLUSTER": [ @@ -165,26 +157,14 @@ ], "AIR_QUALITY_CLUSTER": [], "ALARM_CLUSTER": [], - "APPLICATION_BASIC_CLUSTER": [ - "application-basic-server" - ], - "APPLICATION_LAUNCHER_CLUSTER": [ - "application-launcher-server" - ], - "AUDIO_OUTPUT_CLUSTER": [ - "audio-output-server" - ], + "APPLICATION_BASIC_CLUSTER": ["application-basic-server"], + "APPLICATION_LAUNCHER_CLUSTER": ["application-launcher-server"], + "AUDIO_OUTPUT_CLUSTER": ["audio-output-server"], "BALLAST_CONFIGURATION_CLUSTER": [], - "BARRIER_CONTROL_CLUSTER": [ - "barrier-control-server" - ], - "BASIC_INFORMATION_CLUSTER": [ - "basic-information" - ], + "BARRIER_CONTROL_CLUSTER": ["barrier-control-server"], + "BASIC_INFORMATION_CLUSTER": ["basic-information"], "BINARY_INPUT_BASIC_CLUSTER": [], - "BINDING_CLUSTER": [ - "bindings" - ], + "BINDING_CLUSTER": ["bindings"], "BOOLEAN_STATE_CLUSTER": [], "BRIDGED_DEVICE_BASIC_INFORMATION_CLUSTER": [ "bridged-device-basic-information-server" @@ -195,35 +175,22 @@ "CARBON_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "CARBON_MONOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "CERAMIC_FILTER_MONITORING_CLUSTER": [], - "CHANNEL_CLUSTER": [ - "channel-server" - ], + "CHANNEL_CLUSTER": ["channel-server"], "CHLORAMINES_CONCENTRATION_MEASUREMENT_CLUSTER": [], "CHLORINE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "CHLORODIBROMOMETHANE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "CHLOROFORM_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "COLOR_CONTROL_CLUSTER": [ - "color-control-server" - ], + "COLOR_CONTROL_CLUSTER": ["color-control-server"], "COMMISSIONING_CLUSTER": [], - "CONTENT_LAUNCHER_CLUSTER": [ - "content-launch-server" - ], + "CONTENT_LAUNCHER_CLUSTER": ["content-launch-server"], "COPPER_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "DESCRIPTOR_CLUSTER": [ - "descriptor" - ], + "DESCRIPTOR_CLUSTER": ["descriptor"], "DEVICE_TEMP_CLUSTER": [], - "DIAGNOSTIC_LOGS_CLUSTER": [ - "diagnostic-logs-server" - ], - "DISHWASHER_MODE_SELECT_CLUSTER": [ - "mode-select-server" - ], + "DIAGNOSTIC_LOGS_CLUSTER": ["diagnostic-logs-server"], + "DISHWASHER_ALARM_CLUSTER": ["dishwasher-alarm-server"], + "DISHWASHER_MODE_SELECT_CLUSTER": ["mode-select-server"], "DISSOLVED_OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "DOOR_LOCK_CLUSTER": [ - "door-lock-server" - ], + "DOOR_LOCK_CLUSTER": ["door-lock-server"], "ELECTRICAL_MEASUREMENT_CLUSTER": [], "ELECTROSTATIC_FILTER_MONITORING_CLUSTER": [], "ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER": [ @@ -231,94 +198,50 @@ ], "ETHYLENE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "ETHYLENE_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "FAN_CONTROL_CLUSTER": [ - "fan-control-server" - ], - "FAULT_INJECTION_CLUSTER": [ - "fault-injection-server" - ], + "FAN_CONTROL_CLUSTER": ["fan-control-server"], + "FAULT_INJECTION_CLUSTER": ["fault-injection-server"], "FECAL_COLIFORM_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "FIXED_LABEL_CLUSTER": [ - "fixed-label-server" - ], + "FIXED_LABEL_CLUSTER": ["fixed-label-server"], "FLOW_MEASUREMENT_CLUSTER": [], "FLUORIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "FORMALDEHYDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "FUEL_TANK_MONITORING_CLUSTER": [], - "GENERAL_COMMISSIONING_CLUSTER": [ - "general-commissioning-server" - ], - "GENERAL_DIAGNOSTICS_CLUSTER": [ - "general-diagnostics-server" - ], - "GROUPS_CLUSTER": [ - "groups-server" - ], - "GROUP_KEY_MANAGEMENT_CLUSTER": [ - "group-key-mgmt-server" - ], + "GENERAL_COMMISSIONING_CLUSTER": ["general-commissioning-server"], + "GENERAL_DIAGNOSTICS_CLUSTER": ["general-diagnostics-server"], + "GROUPS_CLUSTER": ["groups-server"], + "GROUP_KEY_MANAGEMENT_CLUSTER": ["group-key-mgmt-server"], "HALOACETIC_ACIDS_CONCENTRATION_MEASUREMENT_CLUSTER": [], "HEPA_FILTER_MONITORING_CLUSTER": [], "HYDROGEN_CONCENTRATION_MEASUREMENT_CLUSTER": [], "HYDROGEN_SULFIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "IAS_ZONE_CLUSTER": [], - "ICD_MANAGEMENT_CLUSTER": [ - "icd-management-server" - ], - "IDENTIFY_CLUSTER": [ - "identify-server" - ], + "ICD_MANAGEMENT_CLUSTER": ["icd-management-server"], + "IDENTIFY_CLUSTER": ["identify-server"], "ILLUMINANCE_MEASUREMENT_CLUSTER": [], "INK_CARTRIDGE_MONITORING_CLUSTER": [], "IONIZING_FILTER_MONITORING_CLUSTER": [], - "KEYPAD_INPUT_CLUSTER": [ - "keypad-input-server" - ], - "LAUNDRY_WASHER_MODE_SELECT_CLUSTER": [ - "mode-select-server" - ], + "KEYPAD_INPUT_CLUSTER": ["keypad-input-server"], + "LAUNDRY_WASHER_MODE_SELECT_CLUSTER": ["mode-select-server"], "LEAD_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "LEVEL_CONTROL_CLUSTER": [ - "level-control" - ], + "LEVEL_CONTROL_CLUSTER": ["level-control"], "LOCALIZATION_CONFIGURATION_CLUSTER": [ "localization-configuration-server" ], - "LOW_POWER_CLUSTER": [ - "low-power-server" - ], + "LOW_POWER_CLUSTER": ["low-power-server"], "MANGANESE_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "MEDIA_INPUT_CLUSTER": [ - "media-input-server" - ], - "MEDIA_PLAYBACK_CLUSTER": [ - "media-playback-server" - ], - "MODE_SELECT_CLUSTER": [ - "mode-select-server" - ], - "NETWORK_COMMISSIONING_CLUSTER": [ - "network-commissioning" - ], + "MEDIA_INPUT_CLUSTER": ["media-input-server"], + "MEDIA_PLAYBACK_CLUSTER": ["media-playback-server"], + "MODE_SELECT_CLUSTER": ["mode-select-server"], + "NETWORK_COMMISSIONING_CLUSTER": ["network-commissioning"], "NITRIC_OXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "NITROGEN_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "OCCUPANCY_SENSING_CLUSTER": [ - "occupancy-sensor-server" - ], - "ON_OFF_CLUSTER": [ - "on-off-server" - ], + "OCCUPANCY_SENSING_CLUSTER": ["occupancy-sensor-server"], + "ON_OFF_CLUSTER": ["on-off-server"], "ON_OFF_SWITCH_CONFIGURATION_CLUSTER": [], - "OPERATIONAL_CREDENTIALS_CLUSTER": [ - "operational-credentials-server" - ], + "OPERATIONAL_CREDENTIALS_CLUSTER": ["operational-credentials-server"], "OTA_BOOTLOAD_CLUSTER": [], - "OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER": [ - "ota-provider" - ], - "OTA_SOFTWARE_UPDATE_REQUESTOR_CLUSTER": [ - "ota-requestor" - ], + "OTA_SOFTWARE_UPDATE_PROVIDER_CLUSTER": ["ota-provider"], + "OTA_SOFTWARE_UPDATE_REQUESTOR_CLUSTER": ["ota-requestor"], "OXYGEN_CONCENTRATION_MEASUREMENT_CLUSTER": [], "OZONE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "OZONE_FILTER_MONITORING_CLUSTER": [], @@ -328,9 +251,7 @@ "POLL_CONTROL_CLUSTER": [], "POWER_CONFIG_CLUSTER": [], "POWER_PROFILE_CLUSTER": [], - "POWER_SOURCE_CLUSTER": [ - "power-source-server" - ], + "POWER_SOURCE_CLUSTER": ["power-source-server"], "POWER_SOURCE_CONFIGURATION_CLUSTER": [ "power-source-configuration-server" ], @@ -343,47 +264,25 @@ ], "PWM_CLUSTER": [], "RADON_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "REFRIGERATOR_ALARM_CLUSTER": [ - "refrigerator-alarm-server" - ], + "REFRIGERATOR_ALARM_CLUSTER": ["refrigerator-alarm-server"], "REFRIGERATOR_AND_TEMPERATURE_CONTROLLED_CABINET_MODE_SELECT_CLUSTER": [ "mode-select-server" ], - "REFRIGERATOR_ALARM_CLUSTER": [ - "refrigerator-alarm-server" - ], + "REFRIGERATOR_ALARM_CLUSTER": ["refrigerator-alarm-server"], "RELATIVE_HUMIDITY_MEASUREMENT_CLUSTER": [], - "RVC_CLEAN_MODE_SELECT_CLUSTER": [ - "mode-select-server" - ], - "RVC_RUN_MODE_SELECT_CLUSTER": [ - "mode-select-server" - ], - "SCENES_CLUSTER": [ - "scenes-server" - ], - "SMOKE_CO_ALARM_CLUSTER": [ - "smoke-co-alarm-server" - ], + "RVC_CLEAN_MODE_SELECT_CLUSTER": ["mode-select-server"], + "RVC_RUN_MODE_SELECT_CLUSTER": ["mode-select-server"], + "SCENES_CLUSTER": ["scenes-server"], + "SMOKE_CO_ALARM_CLUSTER": ["smoke-co-alarm-server"], "SODIUM_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "SOFTWARE_DIAGNOSTICS_CLUSTER": [ - "software-diagnostics-server" - ], + "SOFTWARE_DIAGNOSTICS_CLUSTER": ["software-diagnostics-server"], "SULFATE_CONCENTRATION_MEASUREMENT_CLUSTER": [], "SULFUR_DIOXIDE_CONCENTRATION_MEASUREMENT_CLUSTER": [], - "SWITCH_CLUSTER": [ - "switch-server" - ], - "TARGET_NAVIGATOR_CLUSTER": [ - "target-navigator-server" - ], - "TEMPERATURE_CONTROL_CLUSTER": [ - "temperature-control-server" - ], + "SWITCH_CLUSTER": ["switch-server"], + "TARGET_NAVIGATOR_CLUSTER": ["target-navigator-server"], + "TEMPERATURE_CONTROL_CLUSTER": ["temperature-control-server"], "TEMPERATURE_MEASUREMENT_CLUSTER": [], - "THERMOSTAT_CLUSTER": [ - "thermostat-server" - ], + "THERMOSTAT_CLUSTER": ["thermostat-server"], "THERMOSTAT_USER_INTERFACE_CONFIGURATION_CLUSTER": [ "thermostat-user-interface-configuration-server" ], @@ -391,9 +290,7 @@ "thread-network-diagnostics-server" ], "TIME_CLUSTER": [], - "TIME_FORMAT_LOCALIZATION_CLUSTER": [ - "time-format-localization-server" - ], + "TIME_FORMAT_LOCALIZATION_CLUSTER": ["time-format-localization-server"], "TIME_SYNCHRONIZATION_CLUSTER": [], "TONER_CARTRIDGE_MONITORING_CLUSTER": [], "TOTAL_COLIFORM_BACTERIA_CONCENTRATION_MEASUREMENT_CLUSTER": [], @@ -401,27 +298,15 @@ "TURBIDITY_CONCENTRATION_MEASUREMENT_CLUSTER": [], "TVOC_CONCENTRATION_MEASUREMENT_CLUSTER": [], "UNIT_LOCALIZATION_CLUSTER": [], - "UNIT_TESTING_CLUSTER": [ - "test-cluster-server" - ], - "USER_LABEL_CLUSTER": [ - "user-label-server" - ], + "UNIT_TESTING_CLUSTER": ["test-cluster-server"], + "USER_LABEL_CLUSTER": ["user-label-server"], "UV_FILTER_MONITORING_CLUSTER": [], - "WAKE_ON_LAN_CLUSTER": [ - "wake-on-lan-server" - ], + "WAKE_ON_LAN_CLUSTER": ["wake-on-lan-server"], "WATER_TANK_MONITORING_CLUSTER": [], - "WIFI_NETWORK_DIAGNOSTICS_CLUSTER": [ - "wifi-network-diagnostics-server" - ], - "WINDOW_COVERING_CLUSTER": [ - "window-covering-server" - ], - "TEMPERATURE_CONTROL_CLUSTER": [ - "temperature-control-server" - ], + "WIFI_NETWORK_DIAGNOSTICS_CLUSTER": ["wifi-network-diagnostics-server"], + "WINDOW_COVERING_CLUSTER": ["window-covering-server"], + "TEMPERATURE_CONTROL_CLUSTER": ["temperature-control-server"], "ZEOLITE_FILTER_MONITORING_CLUSTER": [], "ZLL_COMMISSIONING_CLUSTER": [] } -} \ No newline at end of file +} From ac5767493178957d4ca8d61198bd07be2276158c Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 15:28:52 +0000 Subject: [PATCH 11/14] Changes per spec changes --- .../chip/dishwasher-alarm-cluster.xml | 19 +++++-------------- 1 file changed, 5 insertions(+), 14 deletions(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml index 5fcd0ba438c6d5..1b00089f9f9881 100644 --- a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml @@ -17,16 +17,6 @@ limitations under the License. - - - - - - - - - - @@ -47,9 +37,10 @@ limitations under the License. true true - Mask - Latch - State + Mask + Latch + State + State Reset alarm @@ -58,7 +49,7 @@ limitations under the License. Modify enabled alarms - + From 57de025fc5e07531ce8bab30a469257d5a584643 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 13:22:32 -0400 Subject: [PATCH 12/14] Changed name --- .../zcl/data-model/chip/dishwasher-alarm-cluster.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml index 1b00089f9f9881..a7c72885433322 100644 --- a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml @@ -32,7 +32,7 @@ limitations under the License. Appliances Attributes and commands for configuring the Dishwasher alarm. 0x005D - DISHWASHER_ALARM + DISHWASHER_ALARM_CLUSTER true true From c00a0ec3ff0800c3638473a539ef1e348bc029a0 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 13:31:17 -0400 Subject: [PATCH 13/14] Add non-gen'd files --- src/controller/data_model/controller-clusters.matter | 12 ++---------- src/controller/data_model/controller-clusters.zap | 4 ++-- 2 files changed, 4 insertions(+), 12 deletions(-) diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index 52ef1ef7403508..9c157c361d2d31 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -3351,15 +3351,6 @@ client cluster DishwasherAlarm = 93 { kWaterLevelError = 0x20; } - bitmap Feature : BITMAP32 { - kInflowAlarm = 0x1; - kDrainAlarm = 0x2; - kDoorAlarm = 0x4; - kLowTemperatureAlarm = 0x8; - kHighTemperatureAlarm = 0x10; - kWaterLevelAlarm = 0x20; - } - info event Notify = 0 { AlarmMap active = 0; AlarmMap inactive = 1; @@ -3370,6 +3361,7 @@ client cluster DishwasherAlarm = 93 { readonly attribute AlarmMap mask = 0; readonly attribute optional AlarmMap latch = 1; readonly attribute AlarmMap state = 2; + readonly attribute AlarmMap state = 3; readonly attribute command_id generatedCommandList[] = 65528; readonly attribute command_id acceptedCommandList[] = 65529; readonly attribute event_id eventList[] = 65530; @@ -3382,7 +3374,7 @@ client cluster DishwasherAlarm = 93 { } request struct ModifyEnabledAlarmsRequest { - optional AlarmMap mask = 0; + AlarmMap mask = 0; } /** Reset alarm */ diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index e9ddd6a54bec64..a4dd620ff6c0fa 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -13167,7 +13167,7 @@ "name": "Dishwasher Alarm", "code": 93, "mfgCode": null, - "define": "DISHWASHER_ALARM", + "define": "DISHWASHER_ALARM_CLUSTER", "side": "client", "enabled": 1, "commands": [ @@ -13219,7 +13219,7 @@ "name": "Dishwasher Alarm", "code": 93, "mfgCode": null, - "define": "DISHWASHER_ALARM", + "define": "DISHWASHER_ALARM_CLUSTER", "side": "server", "enabled": 0, "attributes": [ From 3d503f34be53f853ad88cc345e7c05d41df4f587 Mon Sep 17 00:00:00 2001 From: Rob Bultman Date: Fri, 16 Jun 2023 14:20:55 -0400 Subject: [PATCH 14/14] Commit after build following merge --- .../chip/dishwasher-alarm-cluster.xml | 2 +- .../data_model/controller-clusters.matter | 2 +- .../data_model/controller-clusters.zap | 202 ++++++------------ .../devicecontroller/ClusterIDMapping.java | 1 + .../devicecontroller/ClusterReadMapping.java | 11 + .../CHIPAttributeTLVValueDecoder.cpp | 15 ++ .../chip/devicecontroller/ChipClusters.java | 19 ++ .../chip/devicecontroller/ChipIdLookup.java | 3 + .../python/chip/clusters/CHIPClusters.py | 6 + .../python/chip/clusters/Objects.py | 30 ++- .../MTRAttributeSpecifiedCheck.mm | 3 + .../MTRAttributeTLVValueDecoder.mm | 11 + .../CHIP/zap-generated/MTRBaseClusters.h | 23 +- .../CHIP/zap-generated/MTRBaseClusters.mm | 52 ++++- .../CHIP/zap-generated/MTRCallbackBridge.h | 31 +++ .../CHIP/zap-generated/MTRCallbackBridge.mm | 23 ++ .../CHIP/zap-generated/MTRClusterConstants.h | 1 + .../CHIP/zap-generated/MTRClusters.h | 4 +- .../CHIP/zap-generated/MTRClusters.mm | 18 +- .../zap-generated/MTRCommandPayloadsObjc.h | 2 +- .../zap-generated/MTRCommandPayloadsObjc.mm | 2 +- .../zap-generated/attributes/Accessors.cpp | 31 +++ .../zap-generated/attributes/Accessors.h | 5 + .../app-common/zap-generated/cluster-enums.h | 11 - .../zap-generated/cluster-objects.cpp | 3 + .../zap-generated/cluster-objects.h | 18 +- .../app-common/zap-generated/ids/Attributes.h | 4 + .../app-common/zap-generated/print-cluster.h | 8 +- .../zap-generated/cluster/Commands.h | 5 + .../cluster/logging/DataModelLogger.cpp | 5 + .../zap-generated/cluster/Commands.h | 79 ++++++- 31 files changed, 427 insertions(+), 203 deletions(-) diff --git a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml index a7c72885433322..b734980d1d78ba 100644 --- a/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/dishwasher-alarm-cluster.xml @@ -40,7 +40,7 @@ limitations under the License. Mask Latch State - State + Supported Reset alarm diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index a36a1ee8b6670a..61e32ebc20e00c 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -3277,7 +3277,7 @@ client cluster DishwasherAlarm = 93 { readonly attribute AlarmMap mask = 0; readonly attribute optional AlarmMap latch = 1; readonly attribute AlarmMap state = 2; - readonly attribute AlarmMap state = 3; + readonly attribute AlarmMap supported = 3; readonly attribute command_id generatedCommandList[] = 65528; readonly attribute command_id acceptedCommandList[] = 65529; readonly attribute event_id eventList[] = 65530; diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index 3932fe0b91bc77..08ca2f42e9fc45 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -16,12 +16,6 @@ } ], "package": [ - { - "pathRelativity": "relativeToZap", - "path": "../../app/zap-templates/app-templates.json", - "type": "gen-templates-json", - "version": "chip-v1" - }, { "pathRelativity": "relativeToZap", "path": "../../app/zap-templates/zcl/zcl.json", @@ -29,6 +23,12 @@ "category": "matter", "version": 1, "description": "Matter SDK ZCL data" + }, + { + "pathRelativity": "relativeToZap", + "path": "../../app/zap-templates/app-templates.json", + "type": "gen-templates-json", + "version": "chip-v1" } ], "endpointTypes": [ @@ -10550,7 +10550,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10614,7 +10614,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10630,7 +10630,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10646,7 +10646,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10662,7 +10662,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10775,30 +10775,14 @@ } ], "attributes": [ - { - "name": "Description", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "SupportedModes", - "code": 1, + "code": 0, "mfgCode": null, "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10809,7 +10793,7 @@ }, { "name": "CurrentMode", - "code": 2, + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", @@ -10825,11 +10809,11 @@ }, { "name": "StartUpMode", - "code": 3, + "code": 2, "mfgCode": null, "side": "server", "type": "int8u", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -10841,7 +10825,7 @@ }, { "name": "OnMode", - "code": 4, + "code": 3, "mfgCode": null, "side": "server", "type": "int8u", @@ -10862,7 +10846,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10878,7 +10862,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10894,7 +10878,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -10910,7 +10894,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11023,30 +11007,14 @@ } ], "attributes": [ - { - "name": "Description", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "SupportedModes", - "code": 1, + "code": 0, "mfgCode": null, "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11057,7 +11025,7 @@ }, { "name": "CurrentMode", - "code": 2, + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", @@ -11073,11 +11041,11 @@ }, { "name": "StartUpMode", - "code": 3, + "code": 2, "mfgCode": null, "side": "server", "type": "int8u", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -11089,7 +11057,7 @@ }, { "name": "OnMode", - "code": 4, + "code": 3, "mfgCode": null, "side": "server", "type": "int8u", @@ -11110,7 +11078,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11126,7 +11094,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11142,7 +11110,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11158,7 +11126,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11483,30 +11451,14 @@ } ], "attributes": [ - { - "name": "Description", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "SupportedModes", - "code": 1, + "code": 0, "mfgCode": null, "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11517,7 +11469,7 @@ }, { "name": "CurrentMode", - "code": 2, + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", @@ -11533,11 +11485,11 @@ }, { "name": "StartUpMode", - "code": 3, + "code": 2, "mfgCode": null, "side": "server", "type": "int8u", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -11549,7 +11501,7 @@ }, { "name": "OnMode", - "code": 4, + "code": 3, "mfgCode": null, "side": "server", "type": "int8u", @@ -11570,7 +11522,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11586,7 +11538,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11602,7 +11554,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11618,7 +11570,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11731,30 +11683,14 @@ } ], "attributes": [ - { - "name": "Description", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "SupportedModes", - "code": 1, + "code": 0, "mfgCode": null, "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11765,7 +11701,7 @@ }, { "name": "CurrentMode", - "code": 2, + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", @@ -11781,11 +11717,11 @@ }, { "name": "StartUpMode", - "code": 3, + "code": 2, "mfgCode": null, "side": "server", "type": "int8u", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -11797,7 +11733,7 @@ }, { "name": "OnMode", - "code": 4, + "code": 3, "mfgCode": null, "side": "server", "type": "int8u", @@ -11818,7 +11754,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11834,7 +11770,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11850,7 +11786,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -11866,7 +11802,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -12413,30 +12349,14 @@ } ], "attributes": [ - { - "name": "Description", - "code": 0, - "mfgCode": null, - "side": "server", - "type": "char_string", - "included": 1, - "storageOption": "RAM", - "singleton": 0, - "bounded": 0, - "defaultValue": "", - "reportable": 1, - "minInterval": 1, - "maxInterval": 65534, - "reportableChange": 0 - }, { "name": "SupportedModes", - "code": 1, + "code": 0, "mfgCode": null, "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -12447,7 +12367,7 @@ }, { "name": "CurrentMode", - "code": 2, + "code": 1, "mfgCode": null, "side": "server", "type": "int8u", @@ -12463,11 +12383,11 @@ }, { "name": "StartUpMode", - "code": 3, + "code": 2, "mfgCode": null, "side": "server", "type": "int8u", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -12479,7 +12399,7 @@ }, { "name": "OnMode", - "code": 4, + "code": 3, "mfgCode": null, "side": "server", "type": "int8u", @@ -12500,7 +12420,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -12516,7 +12436,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -12532,7 +12452,7 @@ "side": "server", "type": "array", "included": 1, - "storageOption": "RAM", + "storageOption": "External", "singleton": 0, "bounded": 0, "defaultValue": "", @@ -12548,7 +12468,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/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java index f965b1a9f1787a..cebc371eb3b19d 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java @@ -7497,6 +7497,7 @@ public enum Attribute { Mask(0L), Latch(1L), State(2L), + Supported(3L), GeneratedCommandList(65528L), AcceptedCommandList(65529L), EventList(65530L), diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java index e7be2adc3bc047..dd904597e3523e 100644 --- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java @@ -7285,6 +7285,17 @@ private static Map readDishwasherAlarmInteractionInfo() readDishwasherAlarmStateCommandParams ); result.put("readStateAttribute", readDishwasherAlarmStateAttributeInteractionInfo); + Map readDishwasherAlarmSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDishwasherAlarmSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DishwasherAlarmCluster) cluster).readSupportedAttribute( + (ChipClusters.LongAttributeCallback) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readDishwasherAlarmSupportedCommandParams + ); + result.put("readSupportedAttribute", readDishwasherAlarmSupportedAttributeInteractionInfo); Map readDishwasherAlarmGeneratedCommandListCommandParams = new LinkedHashMap(); InteractionInfo readDishwasherAlarmGeneratedCommandListAttributeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp index 49118af0e03f1b..a0c89403cc163e 100644 --- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp +++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp @@ -14811,6 +14811,21 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR cppValue.Raw(), value); return value; } + case Attributes::Supported::Id: { + using TypeInfo = Attributes::Supported::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.Raw(), value); + return value; + } case Attributes::GeneratedCommandList::Id: { using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; TypeInfo::DecodableType cppValue; diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 403a03ee87eae6..65c00ac837b937 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -16448,6 +16448,18 @@ public void subscribeStateAttribute( subscribeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } + public void readSupportedAttribute( + LongAttributeCallback callback + ) { + readSupportedAttribute(chipClusterPtr, callback); + } + public void subscribeSupportedAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + public void readGeneratedCommandListAttribute( GeneratedCommandListAttributeCallback callback ) { @@ -16541,6 +16553,13 @@ private native void subscribeStateAttribute(long chipClusterPtr, LongAttributeCallback callback , int minInterval, int maxInterval); + private native void readSupportedAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSupportedAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + private native void readGeneratedCommandListAttribute(long chipClusterPtr, GeneratedCommandListAttributeCallback callback ); diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java index 223e0b4c62c0d4..728f1a309f0d41 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipIdLookup.java @@ -2532,6 +2532,9 @@ public static String attributeIdToName(long clusterId, long attributeId) { if (attributeId == 2L) { return "State"; } + if (attributeId == 3L) { + return "Supported"; + } if (attributeId == 65528L) { return "GeneratedCommandList"; } diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index 3b1a5a60068eee..c2b0dca3ae31bf 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -5167,6 +5167,12 @@ class ChipClusters: "type": "int", "reportable": True, }, + 0x00000003: { + "attributeName": "Supported", + "attributeId": 0x00000003, + "type": "int", + "reportable": True, + }, 0x0000FFF8: { "attributeName": "GeneratedCommandList", "attributeId": 0x0000FFF8, diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 525e99d6af4635..d28e18e802fce4 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -17931,6 +17931,7 @@ def descriptor(cls) -> ClusterObjectDescriptor: ClusterObjectFieldDescriptor(Label="mask", Tag=0x00000000, Type=uint), ClusterObjectFieldDescriptor(Label="latch", Tag=0x00000001, Type=typing.Optional[uint]), ClusterObjectFieldDescriptor(Label="state", Tag=0x00000002, Type=uint), + ClusterObjectFieldDescriptor(Label="supported", Tag=0x00000003, Type=uint), ClusterObjectFieldDescriptor(Label="generatedCommandList", Tag=0x0000FFF8, Type=typing.List[uint]), ClusterObjectFieldDescriptor(Label="acceptedCommandList", Tag=0x0000FFF9, Type=typing.List[uint]), ClusterObjectFieldDescriptor(Label="eventList", Tag=0x0000FFFA, Type=typing.List[uint]), @@ -17942,6 +17943,7 @@ def descriptor(cls) -> ClusterObjectDescriptor: mask: 'uint' = None latch: 'typing.Optional[uint]' = None state: 'uint' = None + supported: 'uint' = None generatedCommandList: 'typing.List[uint]' = None acceptedCommandList: 'typing.List[uint]' = None eventList: 'typing.List[uint]' = None @@ -17958,14 +17960,6 @@ class AlarmMap(IntFlag): kTempTooHigh = 0x10 kWaterLevelError = 0x20 - class Feature(IntFlag): - kInflowAlarm = 0x1 - kDrainAlarm = 0x2 - kDoorAlarm = 0x4 - kLowTemperatureAlarm = 0x8 - kHighTemperatureAlarm = 0x10 - kWaterLevelAlarm = 0x20 - class Commands: @dataclass class Reset(ClusterCommand): @@ -17994,10 +17988,10 @@ class ModifyEnabledAlarms(ClusterCommand): def descriptor(cls) -> ClusterObjectDescriptor: return ClusterObjectDescriptor( Fields=[ - ClusterObjectFieldDescriptor(Label="mask", Tag=0, Type=typing.Optional[uint]), + ClusterObjectFieldDescriptor(Label="mask", Tag=0, Type=uint), ]) - mask: 'typing.Optional[uint]' = None + mask: 'uint' = 0 class Attributes: @dataclass @@ -18048,6 +18042,22 @@ def attribute_type(cls) -> ClusterObjectFieldDescriptor: value: 'uint' = 0 + @dataclass + class Supported(ClusterAttributeDescriptor): + @ChipUtility.classproperty + def cluster_id(cls) -> int: + return 0x005D + + @ChipUtility.classproperty + def attribute_id(cls) -> int: + return 0x00000003 + + @ChipUtility.classproperty + def attribute_type(cls) -> ClusterObjectFieldDescriptor: + return ClusterObjectFieldDescriptor(Type=uint) + + value: 'uint' = 0 + @dataclass class GeneratedCommandList(ClusterAttributeDescriptor): @ChipUtility.classproperty diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm index 39fb07dc5ee1a5..bbcbaf32933ed9 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeSpecifiedCheck.mm @@ -1986,6 +1986,9 @@ static BOOL AttributeIsSpecifiedInDishwasherAlarmCluster(AttributeId aAttributeI case Attributes::State::Id: { return YES; } + case Attributes::Supported::Id: { + return YES; + } case Attributes::GeneratedCommandList::Id: { return YES; } diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm index ca2bccbd9eff8c..e1ce8931f6af79 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRAttributeTLVValueDecoder.mm @@ -10095,6 +10095,17 @@ static id _Nullable DecodeAttributeValueForDishwasherAlarmCluster( value = [NSNumber numberWithUnsignedInt:cppValue.Raw()]; return value; } + case Attributes::Supported::Id: { + using TypeInfo = Attributes::Supported::TypeInfo; + TypeInfo::DecodableType cppValue; + *aError = DataModel::Decode(aReader, cppValue); + if (*aError != CHIP_NO_ERROR) { + return nil; + } + NSNumber * _Nonnull value; + value = [NSNumber numberWithUnsignedInt:cppValue.Raw()]; + return value; + } case Attributes::GeneratedCommandList::Id: { using TypeInfo = Attributes::GeneratedCommandList::TypeInfo; TypeInfo::DecodableType cppValue; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h index d7c9fae89e3b33..fac4fef54246fa 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.h @@ -8551,7 +8551,7 @@ MTR_NEWLY_AVAILABLE * * Modify enabled alarms */ -- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams * _Nullable)params +- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams *)params completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; - (void)readAttributeMaskWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion @@ -8590,6 +8590,18 @@ MTR_NEWLY_AVAILABLE completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE; +- (void)readAttributeSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; +- (void)subscribeAttributeSupportedWithParams:(MTRSubscribeParams *)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler + MTR_NEWLY_AVAILABLE; ++ (void)readAttributeSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion + MTR_NEWLY_AVAILABLE; + - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion MTR_NEWLY_AVAILABLE; - (void)subscribeAttributeGeneratedCommandListWithParams:(MTRSubscribeParams *)params @@ -24778,15 +24790,6 @@ typedef NS_OPTIONS(uint32_t, MTRDishwasherAlarmAlarmMap) { MTRDishwasherAlarmAlarmMapWaterLevelError MTR_NEWLY_AVAILABLE = 0x20, } MTR_NEWLY_AVAILABLE; -typedef NS_OPTIONS(uint32_t, MTRDishwasherAlarmFeature) { - MTRDishwasherAlarmFeatureInflowAlarm MTR_NEWLY_AVAILABLE = 0x1, - MTRDishwasherAlarmFeatureDrainAlarm MTR_NEWLY_AVAILABLE = 0x2, - MTRDishwasherAlarmFeatureDoorAlarm MTR_NEWLY_AVAILABLE = 0x4, - MTRDishwasherAlarmFeatureLowTemperatureAlarm MTR_NEWLY_AVAILABLE = 0x8, - MTRDishwasherAlarmFeatureHighTemperatureAlarm MTR_NEWLY_AVAILABLE = 0x10, - MTRDishwasherAlarmFeatureWaterLevelAlarm MTR_NEWLY_AVAILABLE = 0x20, -} MTR_NEWLY_AVAILABLE; - typedef NS_ENUM(uint8_t, MTROperationalStateErrorState) { MTROperationalStateErrorStateNoError MTR_NEWLY_AVAILABLE = 0x00, MTROperationalStateErrorStateUnableToStartOrResume MTR_NEWLY_AVAILABLE = 0x01, diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm index 5868de812e6355..659c18c5cfcef2 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRBaseClusters.mm @@ -50051,7 +50051,7 @@ - (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params completio std::move(*bridge).DispatchAction(self.device); } -- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams * _Nullable)params +- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams *)params completion:(MTRStatusCompletion)completion { // Make a copy of params before we go async. @@ -50080,12 +50080,7 @@ - (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAla invokeTimeout.SetValue(Seconds16(serverSideProcessingTimeout.unsignedShortValue)); } } - if (params != nil) { - if (params.mask != nil) { - auto & definedValue_0 = request.mask.Emplace(); - definedValue_0 = static_cast>(params.mask.unsignedIntValue); - } - } + request.mask = static_cast>(params.mask.unsignedIntValue); return MTRStartInvokeInteraction(typedBridge, request, exchangeManager, session, successCb, failureCb, self->_endpoint, timedInvokeTimeoutMs, invokeTimeout); @@ -50222,6 +50217,49 @@ + (void)readAttributeStateWithClusterStateCache:(MTRClusterStateCacheContainer * }); } +- (void)readAttributeSupportedWithCompletion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + MTRReadParams * params = [[MTRReadParams alloc] init]; + using TypeInfo = DishwasherAlarm::Attributes::Supported::TypeInfo; + return MTRReadAttribute( + params, completion, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), TypeInfo::GetAttributeId()); +} + +- (void)subscribeAttributeSupportedWithParams:(MTRSubscribeParams * _Nonnull)params + subscriptionEstablished:(MTRSubscriptionEstablishedHandler _Nullable)subscriptionEstablished + reportHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))reportHandler +{ + using TypeInfo = DishwasherAlarm::Attributes::Supported::TypeInfo; + MTRSubscribeAttribute(params, + subscriptionEstablished, reportHandler, self.callbackQueue, self.device, self->_endpoint, TypeInfo::GetClusterId(), + TypeInfo::GetAttributeId()); +} + ++ (void)readAttributeSupportedWithClusterStateCache:(MTRClusterStateCacheContainer *)clusterStateCacheContainer + endpoint:(NSNumber *)endpoint + queue:(dispatch_queue_t)queue + completion:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))completion +{ + auto * bridge = new MTRDishwasherAlarmSupportedAttributeCallbackBridge(queue, completion); + std::move(*bridge).DispatchLocalAction( + clusterStateCacheContainer.baseDevice, ^(DishwasherAlarmSupportedAttributeCallback successCb, MTRErrorCallback failureCb) { + if (clusterStateCacheContainer.cppClusterStateCache) { + chip::app::ConcreteAttributePath path; + using TypeInfo = DishwasherAlarm::Attributes::Supported::TypeInfo; + path.mEndpointId = static_cast([endpoint unsignedShortValue]); + path.mClusterId = TypeInfo::GetClusterId(); + path.mAttributeId = TypeInfo::GetAttributeId(); + TypeInfo::DecodableType value; + CHIP_ERROR err = clusterStateCacheContainer.cppClusterStateCache->Get(path, value); + if (err == CHIP_NO_ERROR) { + successCb(bridge, value); + } + return err; + } + return CHIP_ERROR_NOT_FOUND; + }); +} + - (void)readAttributeGeneratedCommandListWithCompletion:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completion { MTRReadParams * params = [[MTRReadParams alloc] init]; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h index af13b0ab12bdf6..fe247dbf8c9715 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.h @@ -1216,6 +1216,7 @@ typedef void (*SmokeCOAlarmAttributeListListAttributeCallback)(void * context, typedef void (*DishwasherAlarmMaskAttributeCallback)(void *, chip::BitMask); typedef void (*DishwasherAlarmLatchAttributeCallback)(void *, chip::BitMask); typedef void (*DishwasherAlarmStateAttributeCallback)(void *, chip::BitMask); +typedef void (*DishwasherAlarmSupportedAttributeCallback)(void *, chip::BitMask); typedef void (*DishwasherAlarmGeneratedCommandListListAttributeCallback)( void * context, const chip::app::DataModel::DecodableList & data); typedef void (*DishwasherAlarmAcceptedCommandListListAttributeCallback)( @@ -9451,6 +9452,36 @@ class MTRDishwasherAlarmStateAttributeCallbackSubscriptionBridge : public MTRDis MTRSubscriptionEstablishedHandler mEstablishedHandler; }; +class MTRDishwasherAlarmSupportedAttributeCallbackBridge : public MTRCallbackBridge +{ +public: + MTRDishwasherAlarmSupportedAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler) : + MTRCallbackBridge(queue, handler, OnSuccessFn){}; + + MTRDishwasherAlarmSupportedAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRActionBlock action) : + MTRCallbackBridge(queue, handler, action, OnSuccessFn){}; + + static void OnSuccessFn(void * context, chip::BitMask value); +}; + +class MTRDishwasherAlarmSupportedAttributeCallbackSubscriptionBridge : public MTRDishwasherAlarmSupportedAttributeCallbackBridge +{ +public: + MTRDishwasherAlarmSupportedAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, ResponseHandler handler, + MTRActionBlock action, + MTRSubscriptionEstablishedHandler establishedHandler) : + MTRDishwasherAlarmSupportedAttributeCallbackBridge(queue, handler, action), + mEstablishedHandler(establishedHandler) + {} + + void OnSubscriptionEstablished(); + using MTRDishwasherAlarmSupportedAttributeCallbackBridge::KeepAliveOnCallback; + using MTRDishwasherAlarmSupportedAttributeCallbackBridge::OnDone; + +private: + MTRSubscriptionEstablishedHandler mEstablishedHandler; +}; + class MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge : public MTRCallbackBridge { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm index 19c8437dc32090..8c5684ee08b5a2 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCallbackBridge.mm @@ -8971,6 +8971,29 @@ } } +void MTRDishwasherAlarmSupportedAttributeCallbackBridge::OnSuccessFn( + void * context, chip::BitMask value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithUnsignedInt:value.Raw()]; + DispatchSuccess(context, objCValue); +}; + +void MTRDishwasherAlarmSupportedAttributeCallbackSubscriptionBridge::OnSubscriptionEstablished() +{ + if (!mQueue) { + return; + } + + if (mEstablishedHandler != nil) { + dispatch_async(mQueue, mEstablishedHandler); + // On failure, mEstablishedHandler will be cleaned up by our destructor, + // but we can clean it up earlier on successful subscription + // establishment. + mEstablishedHandler = nil; + } +} + void MTRDishwasherAlarmGeneratedCommandListListAttributeCallbackBridge::OnSuccessFn( void * context, const chip::app::DataModel::DecodableList & value) { diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h index 22f0a03011ca2b..5a1cd240610cdc 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusterConstants.h @@ -3811,6 +3811,7 @@ typedef NS_ENUM(uint32_t, MTRAttributeIDType) { MTRAttributeIDTypeClusterDishwasherAlarmAttributeMaskID MTR_NEWLY_AVAILABLE = 0x00000000, MTRAttributeIDTypeClusterDishwasherAlarmAttributeLatchID MTR_NEWLY_AVAILABLE = 0x00000001, MTRAttributeIDTypeClusterDishwasherAlarmAttributeStateID MTR_NEWLY_AVAILABLE = 0x00000002, + MTRAttributeIDTypeClusterDishwasherAlarmAttributeSupportedID MTR_NEWLY_AVAILABLE = 0x00000003, MTRAttributeIDTypeClusterDishwasherAlarmAttributeGeneratedCommandListID MTR_NEWLY_AVAILABLE = MTRAttributeIDTypeGlobalAttributeGeneratedCommandListID, MTRAttributeIDTypeClusterDishwasherAlarmAttributeAcceptedCommandListID MTR_NEWLY_AVAILABLE diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h index 73e412259f063d..98012c5e320252 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.h @@ -2993,7 +2993,7 @@ MTR_NEWLY_AVAILABLE expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; -- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams * _Nullable)params +- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams *)params expectedValues:(NSArray *> * _Nullable)expectedDataValueDictionaries expectedValueInterval:(NSNumber * _Nullable)expectedValueIntervalMs completion:(MTRStatusCompletion)completion MTR_NEWLY_AVAILABLE; @@ -3004,6 +3004,8 @@ MTR_NEWLY_AVAILABLE - (NSDictionary *)readAttributeStateWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; +- (NSDictionary *)readAttributeSupportedWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; + - (NSDictionary *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; - (NSDictionary *)readAttributeAcceptedCommandListWithParams:(MTRReadParams * _Nullable)params MTR_NEWLY_AVAILABLE; diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm index c5a7aa27d101d1..833a31f8401da6 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRClusters.mm @@ -13579,7 +13579,7 @@ - (void)resetWithParams:(MTRDishwasherAlarmClusterResetParams *)params } } -- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams * _Nullable)params +- (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAlarmsParams *)params expectedValues:(NSArray *> *)expectedValues expectedValueInterval:(NSNumber *)expectedValueIntervalMs completion:(MTRStatusCompletion)completion @@ -13626,13 +13626,7 @@ - (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAla invokeTimeout.SetValue(Seconds16(serverSideProcessingTimeout.unsignedShortValue)); } } - if (params != nil) { - if (params.mask != nil) { - auto & definedValue_0 = request.mask.Emplace(); - definedValue_0 - = static_cast>(params.mask.unsignedIntValue); - } - } + request.mask = static_cast>(params.mask.unsignedIntValue); return MTRStartInvokeInteraction(typedBridge, request, exchangeManager, session, successCb, failureCb, self->_endpoint, timedInvokeTimeoutMs, invokeTimeout); @@ -13677,6 +13671,14 @@ - (void)modifyEnabledAlarmsWithParams:(MTRDishwasherAlarmClusterModifyEnabledAla params:params]; } +- (NSDictionary *)readAttributeSupportedWithParams:(MTRReadParams * _Nullable)params +{ + return [self.device readAttributeWithEndpointID:@(_endpoint) + clusterID:@(MTRClusterIDTypeDishwasherAlarmID) + attributeID:@(MTRAttributeIDTypeClusterDishwasherAlarmAttributeSupportedID) + params:params]; +} + - (NSDictionary *)readAttributeGeneratedCommandListWithParams:(MTRReadParams * _Nullable)params { return [self.device readAttributeWithEndpointID:@(_endpoint) diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h index db00b9bd66ebbd..b107be41ce3ae4 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.h @@ -4168,7 +4168,7 @@ MTR_NEWLY_AVAILABLE MTR_NEWLY_AVAILABLE @interface MTRDishwasherAlarmClusterModifyEnabledAlarmsParams : NSObject -@property (nonatomic, copy) NSNumber * _Nullable mask MTR_NEWLY_AVAILABLE; +@property (nonatomic, copy) NSNumber * _Nonnull mask MTR_NEWLY_AVAILABLE; /** * Controls whether the command is a timed command (using Timed Invoke). * diff --git a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm index b2ae21e3d41196..848c6646765fa3 100644 --- a/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/MTRCommandPayloadsObjc.mm @@ -6542,7 +6542,7 @@ - (instancetype)init { if (self = [super init]) { - _mask = nil; + _mask = @(0); _timedInvokeTimeoutMs = nil; _serverSideProcessingTimeout = nil; } diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp index 1d739ac1d30e96..678278b070385e 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp @@ -9464,6 +9464,37 @@ EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask * value) +{ + using Traits = NumericAttributeTraits>; + Traits::StorageType temp; + uint8_t * readable = Traits::ToAttributeStoreRepresentation(temp); + EmberAfStatus status = emberAfReadAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, readable, sizeof(temp)); + VerifyOrReturnError(EMBER_ZCL_STATUS_SUCCESS == status, status); + if (!Traits::CanRepresentValue(/* isNullable = */ false, temp)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + *value = Traits::StorageToWorking(temp); + return status; +} +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value) +{ + using Traits = NumericAttributeTraits>; + if (!Traits::CanRepresentValue(/* isNullable = */ false, value)) + { + return EMBER_ZCL_STATUS_CONSTRAINT_ERROR; + } + Traits::StorageType storageValue; + Traits::WorkingToStorage(value, storageValue); + uint8_t * writable = Traits::ToAttributeStoreRepresentation(storageValue); + return emberAfWriteAttribute(endpoint, Clusters::DishwasherAlarm::Id, Id, writable, ZCL_BITMAP32_ATTRIBUTE_TYPE); +} + +} // namespace Supported + namespace FeatureMap { EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value) diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h index 87ccf5d163218a..caffd88411f479 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h @@ -1775,6 +1775,11 @@ EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask value); } // namespace State +namespace Supported { +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value); // AlarmMap +EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); +} // namespace Supported + namespace FeatureMap { EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index f2251dd4262ab0..a5d586c35408e0 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -1777,17 +1777,6 @@ enum class AlarmMap : uint32_t kTempTooHigh = 0x10, kWaterLevelError = 0x20, }; - -// Bitmap for Feature -enum class Feature : uint32_t -{ - kInflowAlarm = 0x1, - kDrainAlarm = 0x2, - kDoorAlarm = 0x4, - kLowTemperatureAlarm = 0x8, - kHighTemperatureAlarm = 0x10, - kWaterLevelAlarm = 0x20, -}; } // namespace DishwasherAlarm namespace OperationalState { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 4c3f92d96810f8..5a97bc29662fc0 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -13108,6 +13108,9 @@ CHIP_ERROR TypeInfo::DecodableType::Decode(TLV::TLVReader & reader, const Concre case Attributes::State::TypeInfo::GetAttributeId(): ReturnErrorOnFailure(DataModel::Decode(reader, state)); break; + case Attributes::Supported::TypeInfo::GetAttributeId(): + ReturnErrorOnFailure(DataModel::Decode(reader, supported)); + break; case Attributes::GeneratedCommandList::TypeInfo::GetAttributeId(): ReturnErrorOnFailure(DataModel::Decode(reader, generatedCommandList)); break; diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 98c843a48f6dcd..2fc40e8ff14715 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -16463,7 +16463,7 @@ struct Type static constexpr CommandId GetCommandId() { return Commands::ModifyEnabledAlarms::Id; } static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } - Optional> mask; + chip::BitMask mask = static_cast>(0); CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; @@ -16478,7 +16478,7 @@ struct DecodableType static constexpr CommandId GetCommandId() { return Commands::ModifyEnabledAlarms::Id; } static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } - Optional> mask; + chip::BitMask mask = static_cast>(0); CHIP_ERROR Decode(TLV::TLVReader & reader); }; }; // namespace ModifyEnabledAlarms @@ -16522,6 +16522,18 @@ struct TypeInfo static constexpr bool MustUseTimedWrite() { return false; } }; } // namespace State +namespace Supported { +struct TypeInfo +{ + using Type = chip::BitMask; + using DecodableType = chip::BitMask; + using DecodableArgType = chip::BitMask; + + static constexpr ClusterId GetClusterId() { return Clusters::DishwasherAlarm::Id; } + static constexpr AttributeId GetAttributeId() { return Attributes::Supported::Id; } + static constexpr bool MustUseTimedWrite() { return false; } +}; +} // namespace Supported namespace GeneratedCommandList { struct TypeInfo : public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo { @@ -16573,6 +16585,8 @@ struct TypeInfo static_cast>(0); Attributes::State::TypeInfo::DecodableType state = static_cast>(0); + Attributes::Supported::TypeInfo::DecodableType supported = + static_cast>(0); Attributes::GeneratedCommandList::TypeInfo::DecodableType generatedCommandList; Attributes::AcceptedCommandList::TypeInfo::DecodableType acceptedCommandList; Attributes::EventList::TypeInfo::DecodableType eventList; diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h index ceff4406c8d694..b1037728086c98 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h @@ -2962,6 +2962,10 @@ namespace State { static constexpr AttributeId Id = 0x00000002; } // namespace State +namespace Supported { +static constexpr AttributeId Id = 0x00000003; +} // namespace Supported + namespace GeneratedCommandList { static constexpr AttributeId Id = Globals::Attributes::GeneratedCommandList::Id; } // namespace GeneratedCommandList diff --git a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h index 3c74019c71f4d4..8dcd1f3887a8e4 100644 --- a/zzz_generated/app-common/app-common/zap-generated/print-cluster.h +++ b/zzz_generated/app-common/app-common/zap-generated/print-cluster.h @@ -355,10 +355,10 @@ #define CHIP_PRINTCLUSTER_SMOKE_CO_ALARM_CLUSTER #endif -#if defined(ZCL_USING_DISHWASHER_ALARM_SERVER) || defined(ZCL_USING_DISHWASHER_ALARM_CLIENT) -#define CHIP_PRINTCLUSTER_DISHWASHER_ALARM { chip::app::Clusters::DishwasherAlarm::Id, "Dishwasher Alarm" }, +#if defined(ZCL_USING_DISHWASHER_ALARM_CLUSTER_SERVER) || defined(ZCL_USING_DISHWASHER_ALARM_CLUSTER_CLIENT) +#define CHIP_PRINTCLUSTER_DISHWASHER_ALARM_CLUSTER { chip::app::Clusters::DishwasherAlarm::Id, "Dishwasher Alarm" }, #else -#define CHIP_PRINTCLUSTER_DISHWASHER_ALARM +#define CHIP_PRINTCLUSTER_DISHWASHER_ALARM_CLUSTER #endif #if defined(ZCL_USING_OPERATIONAL_STATE_CLUSTER_SERVER) || defined(ZCL_USING_OPERATIONAL_STATE_CLUSTER_CLIENT) @@ -987,7 +987,7 @@ CHIP_PRINTCLUSTER_DISHWASHER_MODE_CLUSTER \ CHIP_PRINTCLUSTER_AIR_QUALITY_CLUSTER \ CHIP_PRINTCLUSTER_SMOKE_CO_ALARM_CLUSTER \ - CHIP_PRINTCLUSTER_DISHWASHER_ALARM \ + CHIP_PRINTCLUSTER_DISHWASHER_ALARM_CLUSTER \ CHIP_PRINTCLUSTER_OPERATIONAL_STATE_CLUSTER \ CHIP_PRINTCLUSTER_OPERATIONAL_STATE_RVC_CLUSTER \ CHIP_PRINTCLUSTER_HEPA_FILTER_MONITORING_CLUSTER \ diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 9669053358901e..453c955ff64d48 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -4533,6 +4533,7 @@ class SmokeCoAlarmSelfTestRequest : public ClusterCommand | * Mask | 0x0000 | | * Latch | 0x0001 | | * State | 0x0002 | +| * Supported | 0x0003 | | * GeneratedCommandList | 0xFFF8 | | * AcceptedCommandList | 0xFFF9 | | * EventList | 0xFFFA | @@ -15466,6 +15467,7 @@ void registerClusterDishwasherAlarm(Commands & commands, CredentialIssuerCommand make_unique(Id, "mask", Attributes::Mask::Id, credsIssuerConfig), // make_unique(Id, "latch", Attributes::Latch::Id, credsIssuerConfig), // make_unique(Id, "state", Attributes::State::Id, credsIssuerConfig), // + make_unique(Id, "supported", Attributes::Supported::Id, credsIssuerConfig), // make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // @@ -15479,6 +15481,8 @@ void registerClusterDishwasherAlarm(Commands & commands, CredentialIssuerCommand Id, "latch", 0, UINT32_MAX, Attributes::Latch::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>>( Id, "state", 0, UINT32_MAX, Attributes::State::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // + make_unique>>( + Id, "supported", 0, UINT32_MAX, Attributes::Supported::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // make_unique>>( Id, "generated-command-list", Attributes::GeneratedCommandList::Id, WriteCommandType::kForceWrite, credsIssuerConfig), // @@ -15496,6 +15500,7 @@ void registerClusterDishwasherAlarm(Commands & commands, CredentialIssuerCommand make_unique(Id, "mask", Attributes::Mask::Id, credsIssuerConfig), // make_unique(Id, "latch", Attributes::Latch::Id, credsIssuerConfig), // make_unique(Id, "state", Attributes::State::Id, credsIssuerConfig), // + make_unique(Id, "supported", Attributes::Supported::Id, credsIssuerConfig), // make_unique(Id, "generated-command-list", Attributes::GeneratedCommandList::Id, credsIssuerConfig), // make_unique(Id, "accepted-command-list", Attributes::AcceptedCommandList::Id, credsIssuerConfig), // make_unique(Id, "event-list", Attributes::EventList::Id, credsIssuerConfig), // diff --git a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp index 4cd8e789631c66..0e1dd3f1abcbaf 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp +++ b/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp @@ -8541,6 +8541,11 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); return DataModelLogger::LogValue("State", 1, value); } + case DishwasherAlarm::Attributes::Supported::Id: { + chip::BitMask value; + ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); + return DataModelLogger::LogValue("Supported", 1, value); + } case DishwasherAlarm::Attributes::GeneratedCommandList::Id: { chip::app::DataModel::DecodableList value; ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value)); diff --git a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h index fe3f7121cc861f..defade81307f62 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/cluster/Commands.h @@ -43994,6 +43994,7 @@ class SubscribeAttributeSmokeCoAlarmClusterRevision : public SubscribeAttribute | * Mask | 0x0000 | | * Latch | 0x0001 | | * State | 0x0002 | +| * Supported | 0x0003 | | * GeneratedCommandList | 0xFFF8 | | * AcceptedCommandList | 0xFFF9 | | * EventList | 0xFFFA | @@ -44074,11 +44075,7 @@ class DishwasherAlarmModifyEnabledAlarms : public ClusterCommand { __auto_type * params = [[MTRDishwasherAlarmClusterModifyEnabledAlarmsParams alloc] init]; params.timedInvokeTimeoutMs = mTimedInteractionTimeoutMs.HasValue() ? [NSNumber numberWithUnsignedShort:mTimedInteractionTimeoutMs.Value()] : nil; - if (mRequest.mask.HasValue()) { - params.mask = [NSNumber numberWithUnsignedInt:mRequest.mask.Value().Raw()]; - } else { - params.mask = nil; - } + params.mask = [NSNumber numberWithUnsignedInt:mRequest.mask.Raw()]; uint16_t repeatCount = mRepeatCount.ValueOr(1); uint16_t __block responsesNeeded = repeatCount; while (repeatCount--) { @@ -44311,6 +44308,76 @@ class SubscribeAttributeDishwasherAlarmState : public SubscribeAttribute { } }; +/* + * Attribute Supported + */ +class ReadDishwasherAlarmSupported : public ReadAttribute { +public: + ReadDishwasherAlarmSupported() + : ReadAttribute("supported") + { + } + + ~ReadDishwasherAlarmSupported() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReadAttribute (0x00000003) on endpoint %u", endpointId); + + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + [cluster readAttributeSupportedWithCompletion:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.Supported response %@", [value description]); + if (error != nil) { + LogNSError("DishwasherAlarm Supported read Error", error); + } + SetCommandExitStatus(error); + }]; + return CHIP_NO_ERROR; + } +}; + +class SubscribeAttributeDishwasherAlarmSupported : public SubscribeAttribute { +public: + SubscribeAttributeDishwasherAlarmSupported() + : SubscribeAttribute("supported") + { + } + + ~SubscribeAttributeDishwasherAlarmSupported() {} + + CHIP_ERROR SendCommand(MTRBaseDevice * device, chip::EndpointId endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000005D) ReportAttribute (0x00000003) on endpoint %u", endpointId); + dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.command", DISPATCH_QUEUE_SERIAL); + __auto_type * cluster = [[MTRBaseClusterDishwasherAlarm alloc] initWithDevice:device + endpointID:@(endpointId) + queue:callbackQueue]; + __auto_type * params = [[MTRSubscribeParams alloc] initWithMinInterval:@(mMinInterval) maxInterval:@(mMaxInterval)]; + if (mKeepSubscriptions.HasValue()) { + params.replaceExistingSubscriptions = !mKeepSubscriptions.Value(); + } + if (mFabricFiltered.HasValue()) { + params.filterByFabric = mFabricFiltered.Value(); + } + if (mAutoResubscribe.HasValue()) { + params.resubscribeAutomatically = mAutoResubscribe.Value(); + } + [cluster subscribeAttributeSupportedWithParams:params + subscriptionEstablished:^() { + mSubscriptionEstablished = YES; + } + reportHandler:^(NSNumber * _Nullable value, NSError * _Nullable error) { + NSLog(@"DishwasherAlarm.Supported response %@", [value description]); + SetCommandExitStatus(error); + }]; + + return CHIP_NO_ERROR; + } +}; + /* * Attribute GeneratedCommandList */ @@ -124368,6 +124435,8 @@ void registerClusterDishwasherAlarm(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), //